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

   1 #include "../../pch.h"
   2 #include <assert.h>
   3
   4 #include "../../rbuild.h"
   5 #include "mingw.h"
   6 #include "modulehandler.h"
   7
   8 using std::string;
   9 using std::vector;
  10
  11 #define CLEAN_FILE(f) clean_files.push_back ( f ); /*if ( module.name == "crt" ) printf ( "%s(%i): clean: %s\n", __FILE__, __LINE__, f.c_str() )*/
  12
  13 static string ros_temp = "$(ROS_TEMPORARY)";
  14 MingwBackend*
  15 MingwModuleHandler::backend = NULL;
  16 FILE*
  17 MingwModuleHandler::fMakefile = NULL;
  18 bool
  19 MingwModuleHandler::use_pch = false;
  20
  21 string
  22 PrefixFilename (
  23         const string& filename,
  24         const string& prefix )
  25 {
  26         if ( !prefix.length() )
  27                 return filename;
  28         string out;
  29         const char* pfilename = filename.c_str();
  30         const char* p1 = strrchr ( pfilename, '/' );
  31         const char* p2 = strrchr ( pfilename, '\\' );
  32         if ( p1 || p2 )
  33         {
  34                 if ( p2 > p1 )
  35                         p1 = p2;
  36                 out += string(pfilename,p1-pfilename) + CSEP;
  37                 pfilename = p1 + 1;
  38         }
  39         out += prefix + pfilename;
  40         return out;
  41 }
  42
  43 string
  44 v2s ( const string_list& v, int wrap_at )
  45 {
  46         if ( !v.size() )
  47                 return "";
  48         string s;
  49         int wrap_count = 0;
  50         for ( size_t i = 0; i < v.size(); i++ )
  51         {
  52                 if ( !v[i].size() )
  53                         continue;
  54                 if ( wrap_at > 0 && wrap_count++ == wrap_at )
  55                         s += " \\\n\t\t";
  56                 else if ( s.size() )
  57                         s += " ";
  58                 s += v[i];
  59         }
  60         return s;
  61 }
  62
  63 string
  64 GetTargetMacro ( const Module& module, bool with_dollar )
  65 {
  66         string s ( module.name );
  67         strupr ( &s[0] );
  68         s += "_TARGET";
  69         if ( with_dollar )
  70                 return ssprintf ( "$(%s)", s.c_str() );
  71         return s;
  72 }
  73
  74 MingwModuleHandler::MingwModuleHandler (
  75         const Module& module_ )
  76
  77         : module(module_)
  78 {
  79 }
  80
  81 MingwModuleHandler::~MingwModuleHandler()
  82 {
  83 }
  84
  85 /*static*/ void
  86 MingwModuleHandler::SetBackend ( MingwBackend* backend_ )
  87 {
  88         backend = backend_;
  89 }
  90
  91 /*static*/ void
  92 MingwModuleHandler::SetMakefile ( FILE* f )
  93 {
  94         fMakefile = f;
  95 }
  96
  97 /*static*/ void
  98 MingwModuleHandler::SetUsePch ( bool b )
  99 {
 100         use_pch = b;
 101 }
 102
 103 /*static*/ string
 104 MingwModuleHandler::PassThruCacheDirectory (
 105         const string &file, bool out )
 106 {
 107         string dir ( GetDirectory ( file ) );
 108         return backend->AddDirectoryTarget ( dir, out ) + SSEP + file;
 109 }
 110
 111 /*static*/ string
 112 MingwModuleHandler::GetTargetFilename (
 113         const Module& module,
 114         string_list* pclean_files )
 115 {
 116         string target = PassThruCacheDirectory (
 117                 FixupTargetFilename ( module.GetPath () ),
 118                 true );
 119         if ( pclean_files )
 120         {
 121                 string_list& clean_files = *pclean_files;
 122                 CLEAN_FILE ( target );
 123         }
 124         return target;
 125 }
 126
 127 /*static*/ string
 128 MingwModuleHandler::GetImportLibraryFilename (
 129         const Module& module,
 130         string_list* pclean_files )
 131 {
 132         string target = PassThruCacheDirectory (
 133                 FixupTargetFilename ( module.GetDependencyPath () ),
 134                 true );
 135         if ( pclean_files )
 136         {
 137                 string_list& clean_files = *pclean_files;
 138                 CLEAN_FILE ( target );
 139         }
 140         return target;
 141 }
 142
 143 /*static*/ MingwModuleHandler*
 144 MingwModuleHandler::InstanciateHandler (
 145         const Module& module,
 146         MingwBackend* backend )
 147 {
 148         MingwModuleHandler* handler;
 149         switch ( module.type )
 150         {
 151                 case BuildTool:
 152                         handler = new MingwBuildToolModuleHandler ( module );
 153                         break;
 154                 case StaticLibrary:
 155                         handler = new MingwStaticLibraryModuleHandler ( module );
 156                         break;
 157                 case ObjectLibrary:
 158                         handler = new MingwObjectLibraryModuleHandler ( module );
 159                         break;
 160                 case Kernel:
 161                         handler = new MingwKernelModuleHandler ( module );
 162                         break;
 163                 case NativeCUI:
 164                         handler = new MingwNativeCUIModuleHandler ( module );
 165                         break;
 166                 case Win32CUI:
 167                         handler = new MingwWin32CUIModuleHandler ( module );
 168                         break;
 169                 case Win32GUI:
 170                         handler = new MingwWin32GUIModuleHandler ( module );
 171                         break;
 172                 case KernelModeDLL:
 173                         handler = new MingwKernelModeDLLModuleHandler ( module );
 174                         break;
 175                 case NativeDLL:
 176                         handler = new MingwNativeDLLModuleHandler ( module );
 177                         break;
 178                 case Win32DLL:
 179                         handler = new MingwWin32DLLModuleHandler ( module );
 180                         break;
 181                 case KernelModeDriver:
 182                         handler = new MingwKernelModeDriverModuleHandler ( module );
 183                         break;
 184                 case BootLoader:
 185                         handler = new MingwBootLoaderModuleHandler ( module );
 186                         break;
 187                 case BootSector:
 188                         handler = new MingwBootSectorModuleHandler ( module );
 189                         break;
 190                 case Iso:
 191                         handler = new MingwIsoModuleHandler ( module );
 192                         break;
 193                 case Test:
 194                         handler = new MingwTestModuleHandler ( module );
 195                         break;
 196                 default:
 197                         throw UnknownModuleTypeException (
 198                                 module.node.location,
 199                                 module.type );
 200                         break;
 201         }
 202         return handler;
 203 }
 204
 205 string
 206 MingwModuleHandler::GetWorkingDirectory () const
 207 {
 208         return ".";
 209 }
 210
 211 string
 212 MingwModuleHandler::GetBasename ( const string& filename ) const
 213 {
 214         size_t index = filename.find_last_of ( '.' );
 215         if ( index != string::npos )
 216                 return filename.substr ( 0, index );
 217         return "";
 218 }
 219
 220 string
 221 MingwModuleHandler::GetActualSourceFilename (
 222         const string& filename ) const
 223 {
 224         string extension = GetExtension ( filename );
 225         if ( extension == ".spec" || extension == "SPEC" )
 226         {
 227                 string basename = GetBasename ( filename );
 228                 return basename + ".stubs.c";
 229         }
 230         else
 231                 return filename;
 232 }
 233
 234 string
 235 MingwModuleHandler::GetModuleArchiveFilename () const
 236 {
 237         if ( module.type == StaticLibrary )
 238                 return GetTargetFilename(module,NULL);
 239         return PassThruCacheDirectory ( ReplaceExtension (
 240                 FixupTargetFilename ( module.GetPath () ),
 241                 ".temp.a" ), false );
 242 }
 243
 244 bool
 245 MingwModuleHandler::IsGeneratedFile ( const File& file ) const
 246 {
 247         string extension = GetExtension ( file.name );
 248         return ( extension == ".spec" || extension == "SPEC" );
 249 }
 250
 251 string
 252 MingwModuleHandler::GetImportLibraryDependency (
 253         const Module& importedModule )
 254 {
 255         string dep;
 256         if ( importedModule.type == ObjectLibrary )
 257                 dep = GetTargetMacro ( importedModule );
 258         else
 259                 dep = GetImportLibraryFilename ( importedModule, NULL );
 260         return dep;
 261 }
 262
 263 void
 264 MingwModuleHandler::GetModuleDependencies (
 265         string_list& dependencies )
 266 {
 267         size_t iend = module.dependencies.size ();
 268
 269         // TODO FIXME - do we *really* not want to call
 270         // GetDefinitionDependencies() if dependencies.size() == 0 ???
 271         if ( iend == 0 )
 272                 return;
 273
 274         for ( size_t i = 0; i < iend; i++ )
 275         {
 276                 const Dependency& dependency = *module.dependencies[i];
 277                 const Module& dependencyModule = *dependency.dependencyModule;
 278                 dependencyModule.GetTargets ( dependencies );
 279         }
 280         GetDefinitionDependencies ( dependencies );
 281 }
 282
 283 void
 284 MingwModuleHandler::GetSourceFilenames (
 285         string_list& list,
 286         bool includeGeneratedFiles ) const
 287 {
 288         size_t i;
 289
 290         const vector<File*>& files = module.non_if_data.files;
 291         for ( i = 0; i < files.size (); i++ )
 292         {
 293                 if ( includeGeneratedFiles || !IsGeneratedFile ( *files[i] ) )
 294                 {
 295                         list.push_back (
 296                                 GetActualSourceFilename ( files[i]->name ) );
 297                 }
 298         }
 299         // intentionally make a copy so that we can append more work in
 300         // the middle of processing without having to go recursive
 301         vector<If*> v = module.non_if_data.ifs;
 302         for ( i = 0; i < v.size (); i++ )
 303         {
 304                 size_t j;
 305                 If& rIf = *v[i];
 306                 // check for sub-ifs to add to list
 307                 const vector<If*>& ifs = rIf.data.ifs;
 308                 for ( j = 0; j < ifs.size (); j++ )
 309                         v.push_back ( ifs[j] );
 310                 const vector<File*>& files = rIf.data.files;
 311                 for ( j = 0; j < files.size (); j++ )
 312                 {
 313                         File& file = *files[j];
 314                         if ( includeGeneratedFiles || !IsGeneratedFile ( file ) )
 315                         {
 316                                 list.push_back (
 317                                         GetActualSourceFilename ( file.name ) );
 318                         }
 319                 }
 320         }
 321 }
 322
 323 void
 324 MingwModuleHandler::GetSourceFilenamesWithoutGeneratedFiles (
 325         string_list& list ) const
 326 {
 327         GetSourceFilenames ( list, false );
 328 }
 329
 330 string
 331 MingwModuleHandler::GetObjectFilename (
 332         const string& sourceFilename,
 333         string_list* pclean_files ) const
 334 {
 335         string newExtension;
 336         string extension = GetExtension ( sourceFilename );
 337         if ( extension == ".rc" || extension == ".RC" )
 338                 newExtension = ".coff";
 339         else if ( extension == ".spec" || extension == ".SPEC" )
 340                 newExtension = ".stubs.o";
 341         else
 342                 newExtension = ".o";
 343         string obj_file = PassThruCacheDirectory (
 344                 FixupTargetFilename (
 345                         ReplaceExtension (
 346                                 sourceFilename, //PrefixFilename(sourceFilename,module.prefix),
 347                                 newExtension ) ),
 348                         false );
 349         if ( pclean_files )
 350         {
 351                 string_list& clean_files = *pclean_files;
 352                 CLEAN_FILE ( obj_file );
 353         }
 354         return obj_file;
 355 }
 356
 357 void
 358 MingwModuleHandler::GenerateCleanTarget () const
 359 {
 360         if ( 0 == clean_files.size() )
 361                 return;
 362         fprintf ( fMakefile, ".PHONY: %s_clean\n", module.name.c_str() );
 363         fprintf ( fMakefile, "%s_clean:\n\t-@$(rm)", module.name.c_str() );
 364         for ( size_t i = 0; i < clean_files.size(); i++ )
 365         {
 366                 if ( 9==((i+1)%10) )
 367                         fprintf ( fMakefile, " 2>$(NUL)\n\t-@$(rm)" );
 368                 fprintf ( fMakefile, " %s", clean_files[i].c_str() );
 369         }
 370         fprintf ( fMakefile, " 2>$(NUL)\n" );
 371         fprintf ( fMakefile, "clean: %s_clean\n\n", module.name.c_str() );
 372 }
 373
 374 string
 375 MingwModuleHandler::GetObjectFilenames ()
 376 {
 377         const vector<File*>& files = module.non_if_data.files;
 378         if ( files.size () == 0 )
 379                 return "";
 380
 381         string objectFilenames ( "" );
 382         for ( size_t i = 0; i < files.size (); i++ )
 383         {
 384                 if ( objectFilenames.size () > 0 )
 385                         objectFilenames += " ";
 386                 objectFilenames +=
 387                         GetObjectFilename ( files[i]->name, NULL );
 388         }
 389         return objectFilenames;
 390 }
 391
 392 string
 393 MingwModuleHandler::GenerateGccDefineParametersFromVector (
 394         const vector<Define*>& defines ) const
 395 {
 396         string parameters;
 397         for ( size_t i = 0; i < defines.size (); i++ )
 398         {
 399                 Define& define = *defines[i];
 400                 if (parameters.length () > 0)
 401                         parameters += " ";
 402                 parameters += "-D";
 403                 parameters += define.name;
 404                 if (define.value.length () > 0)
 405                 {
 406                         parameters += "=";
 407                         parameters += define.value;
 408                 }
 409         }
 410         return parameters;
 411 }
 412
 413 string
 414 MingwModuleHandler::GenerateGccDefineParameters () const
 415 {
 416         string parameters = GenerateGccDefineParametersFromVector ( module.project.non_if_data.defines );
 417         string s = GenerateGccDefineParametersFromVector ( module.non_if_data.defines );
 418         if ( s.length () > 0 )
 419         {
 420                 parameters += " ";
 421                 parameters += s;
 422         }
 423         return parameters;
 424 }
 425
 426 string
 427 MingwModuleHandler::ConcatenatePaths (
 428         const string& path1,
 429         const string& path2 ) const
 430 {
 431         if ( ( path1.length () == 0 ) || ( path1 == "." ) || ( path1 == "./" ) )
 432                 return path2;
 433         if ( path1[path1.length ()] == CSEP )
 434                 return path1 + path2;
 435         else
 436                 return path1 + CSEP + path2;
 437 }
 438
 439 string
 440 MingwModuleHandler::GenerateGccIncludeParametersFromVector ( const vector<Include*>& includes ) const
 441 {
 442         string parameters;
 443         for ( size_t i = 0; i < includes.size (); i++ )
 444         {
 445                 Include& include = *includes[i];
 446                 if ( parameters.length () > 0 )
 447                         parameters += " ";
 448                 parameters += "-I" + include.directory;
 449         }
 450         return parameters;
 451 }
 452
 453 string
 454 MingwModuleHandler::GenerateGccIncludeParameters () const
 455 {
 456         string parameters = GenerateGccIncludeParametersFromVector ( module.non_if_data.includes );
 457         string s = GenerateGccIncludeParametersFromVector ( module.project.non_if_data.includes );
 458         if ( s.length () > 0 )
 459         {
 460                 parameters += " ";
 461                 parameters += s;
 462         }
 463         return parameters;
 464 }
 465
 466
 467 string
 468 MingwModuleHandler::GenerateCompilerParametersFromVector ( const vector<CompilerFlag*>& compilerFlags ) const
 469 {
 470         string parameters;
 471         for ( size_t i = 0; i < compilerFlags.size (); i++ )
 472         {
 473                 CompilerFlag& compilerFlag = *compilerFlags[i];
 474                 if ( parameters.length () > 0 )
 475                         parameters += " ";
 476                 parameters += compilerFlag.flag;
 477         }
 478         return parameters;
 479 }
 480
 481 string
 482 MingwModuleHandler::GenerateLinkerParametersFromVector ( const vector<LinkerFlag*>& linkerFlags ) const
 483 {
 484         string parameters;
 485         for ( size_t i = 0; i < linkerFlags.size (); i++ )
 486         {
 487                 LinkerFlag& linkerFlag = *linkerFlags[i];
 488                 if ( parameters.length () > 0 )
 489                         parameters += " ";
 490                 parameters += linkerFlag.flag;
 491         }
 492         return parameters;
 493 }
 494
 495 string
 496 MingwModuleHandler::GenerateImportLibraryDependenciesFromVector (
 497         const vector<Library*>& libraries )
 498 {
 499         string dependencies ( "" );
 500         int wrap_count = 0;
 501         for ( size_t i = 0; i < libraries.size (); i++ )
 502         {
 503                 if ( wrap_count++ == 5 )
 504                         dependencies += " \\\n\t\t", wrap_count = 0;
 505                 else if ( dependencies.size () > 0 )
 506                         dependencies += " ";
 507                 dependencies += GetImportLibraryDependency ( *libraries[i]->imported_module );
 508         }
 509         return dependencies;
 510 }
 511
 512 string
 513 MingwModuleHandler::GenerateLinkerParameters () const
 514 {
 515         return GenerateLinkerParametersFromVector ( module.linkerFlags );
 516 }
 517
 518 void
 519 MingwModuleHandler::GenerateMacro (
 520         const char* assignmentOperation,
 521         const string& macro,
 522         const IfableData& data,
 523         const vector<CompilerFlag*>* compilerFlags )
 524 {
 525         size_t i;
 526
 527         fprintf (
 528                 fMakefile,
 529                 "%s %s",
 530                 macro.c_str(),
 531                 assignmentOperation );
 532
 533         if ( compilerFlags != NULL )
 534         {
 535                 string compilerParameters = GenerateCompilerParametersFromVector ( *compilerFlags );
 536                 if ( compilerParameters.size () > 0 )
 537                 {
 538                         fprintf (
 539                                 fMakefile,
 540                                 " %s",
 541                                 compilerParameters.c_str () );
 542                 }
 543         }
 544
 545         for ( i = 0; i < data.includes.size(); i++ )
 546         {
 547                 fprintf (
 548                         fMakefile,
 549                         " -I%s",
 550                         data.includes[i]->directory.c_str() );
 551         }
 552         for ( i = 0; i < data.defines.size(); i++ )
 553         {
 554                 Define& d = *data.defines[i];
 555                 fprintf (
 556                         fMakefile,
 557                         " -D%s",
 558                         d.name.c_str() );
 559                 if ( d.value.size() )
 560                         fprintf (
 561                                 fMakefile,
 562                                 "=%s",
 563                                 d.value.c_str() );
 564         }
 565         fprintf ( fMakefile, "\n" );
 566 }
 567
 568 void
 569 MingwModuleHandler::GenerateMacros (
 570         const char* assignmentOperation,
 571         const IfableData& data,
 572         const vector<CompilerFlag*>* compilerFlags,
 573         const vector<LinkerFlag*>* linkerFlags )
 574 {
 575         size_t i;
 576
 577         if ( data.includes.size () > 0 || data.defines.size () > 0 )
 578         {
 579                 GenerateMacro ( assignmentOperation,
 580                                 cflagsMacro,
 581                                 data,
 582                                 compilerFlags );
 583                 GenerateMacro ( assignmentOperation,
 584                                 windresflagsMacro,
 585                                 data,
 586                                 compilerFlags );
 587         }
 588
 589         if ( linkerFlags != NULL )
 590         {
 591                 string linkerParameters = GenerateLinkerParametersFromVector ( *linkerFlags );
 592                 if ( linkerParameters.size () > 0 )
 593                 {
 594                         fprintf (
 595                                 fMakefile,
 596                                 "%s %s %s\n",
 597                                 linkerflagsMacro.c_str (),
 598                                 assignmentOperation,
 599                                 linkerParameters.c_str() );
 600                 }
 601         }
 602
 603         if ( data.libraries.size () > 0 )
 604         {
 605                 string deps = GenerateImportLibraryDependenciesFromVector ( data.libraries );
 606                 if ( deps.size () > 0 )
 607                 {
 608                         fprintf (
 609                                 fMakefile,
 610                                 "%s %s %s\n",
 611                                 libsMacro.c_str(),
 612                                 assignmentOperation,
 613                                 deps.c_str() );
 614                 }
 615         }
 616
 617         const vector<If*>& ifs = data.ifs;
 618         for ( i = 0; i < ifs.size(); i++ )
 619         {
 620                 If& rIf = *ifs[i];
 621                 if ( rIf.data.defines.size()
 622                         || rIf.data.includes.size()
 623                         || rIf.data.libraries.size()
 624                         || rIf.data.files.size()
 625                         || rIf.data.ifs.size() )
 626                 {
 627                         fprintf (
 628                                 fMakefile,
 629                                 "ifeq (\"$(%s)\",\"%s\")\n",
 630                                 rIf.property.c_str(),
 631                                 rIf.value.c_str() );
 632                         GenerateMacros (
 633                                 "+=",
 634                                 rIf.data,
 635                                 NULL,
 636                                 NULL );
 637                         fprintf (
 638                                 fMakefile,
 639                                 "endif\n\n" );
 640                 }
 641         }
 642 }
 643
 644 void
 645 MingwModuleHandler::GenerateObjectMacros (
 646         const char* assignmentOperation,
 647         const IfableData& data,
 648         const vector<CompilerFlag*>* compilerFlags,
 649         const vector<LinkerFlag*>* linkerFlags )
 650 {
 651         size_t i;
 652
 653         const vector<File*>& files = data.files;
 654         if ( files.size () > 0 )
 655         {
 656                 for ( i = 0; i < files.size (); i++ )
 657                 {
 658                         File& file = *files[i];
 659                         if ( file.first )
 660                         {
 661                                 fprintf ( fMakefile,
 662                                         "%s := %s $(%s)\n",
 663                                         objectsMacro.c_str(),
 664                                         GetObjectFilename (
 665                                                 file.name, NULL ).c_str (),
 666                                         objectsMacro.c_str() );
 667                         }
 668                 }
 669                 fprintf (
 670                         fMakefile,
 671                         "%s %s",
 672                         objectsMacro.c_str (),
 673                         assignmentOperation );
 674                 for ( i = 0; i < files.size(); i++ )
 675                 {
 676                         File& file = *files[i];
 677                         if ( !file.first )
 678                         {
 679                                 fprintf (
 680                                         fMakefile,
 681                                         "%s%s",
 682                                         ( i%10 == 9 ? " \\\n\t" : " " ),
 683                                         GetObjectFilename (
 684                                                 file.name, NULL ).c_str () );
 685                         }
 686                 }
 687                 fprintf ( fMakefile, "\n" );
 688         }
 689
 690         const vector<If*>& ifs = data.ifs;
 691         for ( i = 0; i < ifs.size(); i++ )
 692         {
 693                 If& rIf = *ifs[i];
 694                 if ( rIf.data.defines.size()
 695                         || rIf.data.includes.size()
 696                         || rIf.data.libraries.size()
 697                         || rIf.data.files.size()
 698                         || rIf.data.ifs.size() )
 699                 {
 700                         fprintf (
 701                                 fMakefile,
 702                                 "ifeq (\"$(%s)\",\"%s\")\n",
 703                                 rIf.property.c_str(),
 704                                 rIf.value.c_str() );
 705                         GenerateObjectMacros (
 706                                 "+=",
 707                                 rIf.data,
 708                                 NULL,
 709                                 NULL );
 710                         fprintf (
 711                                 fMakefile,
 712                                 "endif\n\n" );
 713                 }
 714         }
 715 }
 716
 717 void
 718 MingwModuleHandler::GenerateGccCommand (
 719         const string& sourceFilename,
 720         const string& cc,
 721         const string& cflagsMacro )
 722 {
 723         string deps = sourceFilename;
 724         if ( module.pch && use_pch )
 725                 deps += " " + module.pch->header + ".gch";
 726         string objectFilename = GetObjectFilename (
 727                 sourceFilename, NULL );
 728         fprintf ( fMakefile,
 729                   "%s: %s %s\n",
 730                   objectFilename.c_str (),
 731                   deps.c_str (),
 732                   GetDirectory ( objectFilename ).c_str () );
 733         fprintf ( fMakefile, "\t$(ECHO_CC)\n" );
 734         fprintf ( fMakefile,
 735                  "\t%s -c $< -o $@ %s\n",
 736                  cc.c_str (),
 737                  cflagsMacro.c_str () );
 738 }
 739
 740 void
 741 MingwModuleHandler::GenerateGccAssemblerCommand (
 742         const string& sourceFilename,
 743         const string& cc,
 744         const string& cflagsMacro )
 745 {
 746         string objectFilename = GetObjectFilename (
 747                 sourceFilename, &clean_files );
 748         fprintf ( fMakefile,
 749                   "%s: %s %s\n",
 750                   objectFilename.c_str (),
 751                   sourceFilename.c_str (),
 752                   GetDirectory ( objectFilename ).c_str () );
 753         fprintf ( fMakefile, "\t$(ECHO_GAS)\n" );
 754         fprintf ( fMakefile,
 755                   "\t%s -x assembler-with-cpp -c $< -o $@ -D__ASM__ %s\n",
 756                   cc.c_str (),
 757                   cflagsMacro.c_str () );
 758 }
 759
 760 void
 761 MingwModuleHandler::GenerateNasmCommand (
 762         const string& sourceFilename,
 763         const string& nasmflagsMacro )
 764 {
 765         string objectFilename = GetObjectFilename (
 766                 sourceFilename, &clean_files );
 767         fprintf ( fMakefile,
 768                   "%s: %s %s\n",
 769                   objectFilename.c_str (),
 770                   sourceFilename.c_str (),
 771                   GetDirectory ( objectFilename ).c_str () );
 772         fprintf ( fMakefile, "\t$(ECHO_NASM)\n" );
 773         fprintf ( fMakefile,
 774                   "\t%s -f win32 $< -o $@ %s\n",
 775                   "$(Q)nasm",
 776                   nasmflagsMacro.c_str () );
 777 }
 778
 779 void
 780 MingwModuleHandler::GenerateWindresCommand (
 781         const string& sourceFilename,
 782         const string& windresflagsMacro )
 783 {
 784         string objectFilename =
 785                 GetObjectFilename ( sourceFilename, &clean_files );
 786         string rciFilename = ros_temp +
 787                 ReplaceExtension ( sourceFilename, ".rci" );
 788         string resFilename = ros_temp +
 789                 ReplaceExtension ( sourceFilename, ".res" );
 790         fprintf ( fMakefile,
 791                   "%s: %s %s $(WRC_TARGET)\n",
 792                   objectFilename.c_str (),
 793                   sourceFilename.c_str (),
 794                   GetDirectory ( objectFilename ).c_str () );
 795         fprintf ( fMakefile, "\t$(ECHO_WRC)\n" );
 796         fprintf ( fMakefile,
 797                  "\t${gcc} -xc -E -DRC_INVOKED ${%s} %s > %s\n",
 798                  windresflagsMacro.c_str (),
 799                  sourceFilename.c_str (),
 800                  rciFilename.c_str () );
 801         fprintf ( fMakefile,
 802                  "\t$(Q)$(WRC_TARGET) ${%s} %s %s\n",
 803                  windresflagsMacro.c_str (),
 804                  rciFilename.c_str (),
 805                  resFilename.c_str () );
 806         fprintf ( fMakefile,
 807                  "\t-@${rm} %s 2>$(NUL)\n",
 808                  rciFilename.c_str () );
 809         fprintf ( fMakefile,
 810                  "\t${windres} %s -o $@\n",
 811                  resFilename.c_str () );
 812         fprintf ( fMakefile,
 813                  "\t-@${rm} %s 2>$(NUL)\n",
 814                  resFilename.c_str () );
 815 }
 816
 817 void
 818 MingwModuleHandler::GenerateWinebuildCommands (
 819         const string& sourceFilename )
 820 {
 821         string basename = GetBasename ( sourceFilename );
 822
 823         string def_file = PassThruCacheDirectory (
 824                 basename + ".spec.def",
 825                 false );
 826         CLEAN_FILE(def_file);
 827
 828         string stub_file = PassThruCacheDirectory (
 829                 basename + ".stubs.c",
 830                 false );
 831         CLEAN_FILE(stub_file)
 832
 833         fprintf ( fMakefile,
 834                   "%s: %s $(WINEBUILD_TARGET)\n",
 835                   def_file.c_str (),
 836                   sourceFilename.c_str () );
 837         fprintf ( fMakefile, "\t$(ECHO_WINEBLD)\n" );
 838         fprintf ( fMakefile,
 839                   "\t%s --def=%s -o %s\n",
 840                   "$(Q)$(WINEBUILD_TARGET)",
 841                   sourceFilename.c_str (),
 842                   def_file.c_str () );
 843
 844         fprintf ( fMakefile,
 845                   "%s: %s\n",
 846                   stub_file.c_str (),
 847                   sourceFilename.c_str () );
 848         fprintf ( fMakefile, "\t$(ECHO_WINEBLD)\n" );
 849         fprintf ( fMakefile,
 850                   "\t%s --pedll=%s -o %s\n",
 851                   "$(Q)$(WINEBUILD_TARGET)",
 852                   sourceFilename.c_str (),
 853                   stub_file.c_str () );
 854 }
 855
 856 void
 857 MingwModuleHandler::GenerateCommands (
 858         const string& sourceFilename,
 859         const string& cc,
 860         const string& cppc,
 861         const string& cflagsMacro,
 862         const string& nasmflagsMacro,
 863         const string& windresflagsMacro )
 864 {
 865         string extension = GetExtension ( sourceFilename );
 866         if ( extension == ".c" || extension == ".C" )
 867         {
 868                 GenerateGccCommand ( sourceFilename,
 869                                      cc,
 870                                      cflagsMacro );
 871                 return;
 872         }
 873         else if ( extension == ".cc" || extension == ".CC" ||
 874                   extension == ".cpp" || extension == ".CPP" ||
 875                   extension == ".cxx" || extension == ".CXX" )
 876         {
 877                 GenerateGccCommand ( sourceFilename,
 878                                      cppc,
 879                                      cflagsMacro );
 880                 return;
 881         }
 882         else if ( extension == ".s" || extension == ".S" )
 883         {
 884                 GenerateGccAssemblerCommand ( sourceFilename,
 885                                               cc,
 886                                               cflagsMacro );
 887                 return;
 888         }
 889         else if ( extension == ".asm" || extension == ".ASM" )
 890         {
 891                 GenerateNasmCommand ( sourceFilename,
 892                                       nasmflagsMacro );
 893                 return;
 894         }
 895         else if ( extension == ".rc" || extension == ".RC" )
 896         {
 897                 GenerateWindresCommand ( sourceFilename,
 898                                          windresflagsMacro );
 899                 return;
 900         }
 901         else if ( extension == ".spec" || extension == ".SPEC" )
 902         {
 903                 GenerateWinebuildCommands ( sourceFilename );
 904                 GenerateGccCommand ( GetActualSourceFilename ( sourceFilename ),
 905                                      cc,
 906                                      cflagsMacro );
 907                 return;
 908         }
 909
 910         throw InvalidOperationException ( __FILE__,
 911                                           __LINE__,
 912                                           "Unsupported filename extension '%s' in file '%s'",
 913                                           extension.c_str (),
 914                                           sourceFilename.c_str () );
 915 }
 916
 917 void
 918 MingwModuleHandler::GenerateLinkerCommand (
 919         const string& dependencies,
 920         const string& linker,
 921         const string& linkerParameters,
 922         const string& objectsMacro,
 923         const string& libsMacro )
 924 {
 925         string target ( GetTargetMacro ( module ) );
 926         string target_folder ( GetDirectory ( GetTargetFilename ( module, NULL ) ) );
 927
 928         fprintf ( fMakefile,
 929                 "%s: %s %s $(RSYM_TARGET)\n",
 930                 target.c_str (),
 931                 dependencies.c_str (),
 932                 target_folder.c_str () );
 933         fprintf ( fMakefile, "\t$(ECHO_LD)\n" );
 934         string targetName ( module.GetTargetName () );
 935         if ( module.importLibrary != NULL )
 936         {
 937                 string base_tmp = ros_temp + module.name + ".base.tmp";
 938                 CLEAN_FILE ( base_tmp );
 939                 string junk_tmp = ros_temp + module.name + ".junk.tmp";
 940                 CLEAN_FILE ( junk_tmp );
 941                 string temp_exp = ros_temp + module.name + ".temp.exp";
 942                 CLEAN_FILE ( temp_exp );
 943                 string def_file = module.GetBasePath () + SSEP + module.importLibrary->definition;
 944
 945                 fprintf ( fMakefile,
 946                           "\t%s %s -Wl,--base-file,%s -o %s %s %s %s\n",
 947                           linker.c_str (),
 948                           linkerParameters.c_str (),
 949                           base_tmp.c_str (),
 950                           junk_tmp.c_str (),
 951                           objectsMacro.c_str (),
 952                           libsMacro.c_str (),
 953                           GetLinkerMacro ().c_str () );
 954
 955                 fprintf ( fMakefile,
 956                           "\t-@${rm} %s 2>$(NUL)\n",
 957                           junk_tmp.c_str () );
 958
 959                 string killAt = module.mangledSymbols ? "" : "--kill-at";
 960                 fprintf ( fMakefile,
 961                           "\t${dlltool} --dllname %s --base-file %s --def %s --output-exp %s %s\n",
 962                           targetName.c_str (),
 963                           base_tmp.c_str (),
 964                           def_file.c_str (),
 965                           temp_exp.c_str (),
 966                           killAt.c_str () );
 967
 968                 fprintf ( fMakefile,
 969                           "\t-@${rm} %s 2>$(NUL)\n",
 970                           base_tmp.c_str () );
 971
 972                 fprintf ( fMakefile,
 973                           "\t%s %s %s -o %s %s %s %s\n",
 974                           linker.c_str (),
 975                           linkerParameters.c_str (),
 976                           temp_exp.c_str (),
 977                           target.c_str (),
 978                           objectsMacro.c_str (),
 979                           libsMacro.c_str (),
 980                           GetLinkerMacro ().c_str () );
 981
 982                 fprintf ( fMakefile,
 983                           "\t-@${rm} %s 2>$(NUL)\n",
 984                           temp_exp.c_str () );
 985         }
 986         else
 987         {
 988                 fprintf ( fMakefile,
 989                           "\t%s %s -o %s %s %s %s\n",
 990                           linker.c_str (),
 991                           linkerParameters.c_str (),
 992                           target.c_str (),
 993                           objectsMacro.c_str (),
 994                           libsMacro.c_str (),
 995                           GetLinkerMacro ().c_str () );
 996         }
 997
 998         fprintf ( fMakefile, "\t$(ECHO_RSYM)\n" );
 999         fprintf ( fMakefile,
1000                   "\t$(Q)$(RSYM_TARGET) $@ $@\n\n" );
1001 }
1002
1003 void
1004 MingwModuleHandler::GeneratePhonyTarget() const
1005 {
1006         string targetMacro ( GetTargetMacro(module) );
1007         fprintf ( fMakefile, ".PHONY: %s\n\n",
1008                   targetMacro.c_str ());
1009         fprintf ( fMakefile, "%s: %s\n",
1010                   targetMacro.c_str (),
1011                   GetDirectory(GetTargetFilename(module,NULL)).c_str () );
1012 }
1013
1014 void
1015 MingwModuleHandler::GenerateObjectFileTargets (
1016         const IfableData& data,
1017         const string& cc,
1018         const string& cppc,
1019         const string& cflagsMacro,
1020         const string& nasmflagsMacro,
1021         const string& windresflagsMacro )
1022 {
1023         size_t i;
1024
1025         const vector<File*>& files = data.files;
1026         for ( i = 0; i < files.size (); i++ )
1027         {
1028                 string sourceFilename = files[i]->name;
1029                 GenerateCommands ( sourceFilename,
1030                                    cc,
1031                                    cppc,
1032                                    cflagsMacro,
1033                                    nasmflagsMacro,
1034                                    windresflagsMacro );
1035                 fprintf ( fMakefile,
1036                           "\n" );
1037         }
1038
1039         const vector<If*>& ifs = data.ifs;
1040         for ( i = 0; i < ifs.size(); i++ )
1041         {
1042                 GenerateObjectFileTargets ( ifs[i]->data,
1043                                             cc,
1044                                             cppc,
1045                                             cflagsMacro,
1046                                             nasmflagsMacro,
1047                                             windresflagsMacro );
1048         }
1049 }
1050
1051 void
1052 MingwModuleHandler::GenerateObjectFileTargets (
1053         const string& cc,
1054         const string& cppc,
1055         const string& cflagsMacro,
1056         const string& nasmflagsMacro,
1057         const string& windresflagsMacro )
1058 {
1059         if ( module.pch )
1060         {
1061                 const string& pch_file = module.pch->header;
1062                 string gch_file = pch_file + ".gch";
1063                 CLEAN_FILE(gch_file);
1064                 if ( use_pch )
1065                 {
1066                         fprintf (
1067                                 fMakefile,
1068                                 "%s: %s\n",
1069                                 gch_file.c_str(),
1070                                 pch_file.c_str() );
1071                         fprintf ( fMakefile, "\t$(ECHO_PCH)\n" );
1072                         fprintf (
1073                                 fMakefile,
1074                                 "\t%s -o %s %s -g %s\n\n",
1075                                 ( module.cplusplus ? cppc.c_str() : cc.c_str() ),
1076                                 gch_file.c_str(),
1077                                 cflagsMacro.c_str(),
1078                                 pch_file.c_str() );
1079                 }
1080         }
1081
1082         GenerateObjectFileTargets ( module.non_if_data,
1083                                     cc,
1084                                     cppc,
1085                                     cflagsMacro,
1086                                     nasmflagsMacro,
1087                                     windresflagsMacro );
1088         fprintf ( fMakefile, "\n" );
1089 }
1090
1091 string
1092 MingwModuleHandler::GenerateArchiveTarget ( const string& ar,
1093                                             const string& objs_macro ) const
1094 {
1095         string archiveFilename ( GetModuleArchiveFilename () );
1096
1097         fprintf ( fMakefile,
1098                   "%s: %s %s\n",
1099                   archiveFilename.c_str (),
1100                   objs_macro.c_str (),
1101                   GetDirectory(archiveFilename).c_str() );
1102
1103         fprintf ( fMakefile, "\t$(ECHO_AR)\n" );
1104
1105         fprintf ( fMakefile,
1106                   "\t%s -rc $@ %s\n\n",
1107                   ar.c_str (),
1108                   objs_macro.c_str ());
1109
1110         return archiveFilename;
1111 }
1112
1113 string
1114 MingwModuleHandler::GetCFlagsMacro () const
1115 {
1116         return ssprintf ( "$(%s_CFLAGS)",
1117                           module.name.c_str () );
1118 }
1119
1120 /*static*/ string
1121 MingwModuleHandler::GetObjectsMacro ( const Module& module )
1122 {
1123         return ssprintf ( "$(%s_OBJS)",
1124                           module.name.c_str () );
1125 }
1126
1127 string
1128 MingwModuleHandler::GetLinkingDependenciesMacro () const
1129 {
1130         return ssprintf ( "$(%s_LINKDEPS)", module.name.c_str () );
1131 }
1132
1133 string
1134 MingwModuleHandler::GetLibsMacro () const
1135 {
1136         return ssprintf ( "$(%s_LIBS)", module.name.c_str () );
1137 }
1138
1139 string
1140 MingwModuleHandler::GetLinkerMacro () const
1141 {
1142         return ssprintf ( "$(%s_LFLAGS)",
1143                           module.name.c_str () );
1144 }
1145
1146 string
1147 MingwModuleHandler::GetModuleTargets ( const Module& module )
1148 {
1149         if ( module.type == ObjectLibrary )
1150                 return GetObjectsMacro ( module );
1151         else
1152                 return GetTargetFilename ( module, NULL );
1153 }
1154
1155 void
1156 MingwModuleHandler::GenerateObjectMacro ()
1157 {
1158         objectsMacro = ssprintf ("%s_OBJS", module.name.c_str ());
1159
1160         GenerateObjectMacros (
1161                 "=",
1162                 module.non_if_data,
1163                 &module.compilerFlags,
1164                 &module.linkerFlags );
1165
1166         // future references to the macro will be to get its values
1167         objectsMacro = ssprintf ("$(%s)", objectsMacro.c_str ());
1168 }
1169
1170 void
1171 MingwModuleHandler::GenerateTargetMacro ()
1172 {
1173         fprintf ( fMakefile,
1174                 "%s := %s\n",
1175                 GetTargetMacro ( module, false ).c_str (),
1176                 GetModuleTargets ( module ).c_str () );
1177 }
1178
1179 void
1180 MingwModuleHandler::GenerateOtherMacros ()
1181 {
1182         cflagsMacro = ssprintf ("%s_CFLAGS", module.name.c_str ());
1183         nasmflagsMacro = ssprintf ("%s_NASMFLAGS", module.name.c_str ());
1184         windresflagsMacro = ssprintf ("%s_RCFLAGS", module.name.c_str ());
1185         linkerflagsMacro = ssprintf ("%s_LFLAGS", module.name.c_str ());
1186         libsMacro = ssprintf("%s_LIBS", module.name.c_str ());
1187         linkDepsMacro = ssprintf ("%s_LINKDEPS", module.name.c_str ());
1188
1189         GenerateMacros (
1190                 "=",
1191                 module.non_if_data,
1192                 &module.compilerFlags,
1193                 &module.linkerFlags );
1194
1195         if ( module.importLibrary )
1196         {
1197                 string_list s;
1198                 const vector<File*>& files = module.non_if_data.files;
1199                 for ( size_t i = 0; i < files.size (); i++ )
1200                 {
1201                         File& file = *files[i];
1202                         string extension = GetExtension ( file.name );
1203                         if ( extension == ".spec" || extension == ".SPEC" )
1204                                 GetSpecObjectDependencies ( s, file.name );
1205                 }
1206                 if ( s.size () > 0 )
1207                 {
1208                         fprintf (
1209                                 fMakefile,
1210                                 "%s +=",
1211                                 linkDepsMacro.c_str() );
1212                         for ( size_t i = 0; i < s.size(); i++ )
1213                                 fprintf ( fMakefile,
1214                                           " %s",
1215                                           s[i].c_str () );
1216                         fprintf ( fMakefile, "\n" );
1217                 }
1218         }
1219
1220         fprintf (
1221                 fMakefile,
1222                 "%s += $(PROJECT_CFLAGS)\n",
1223                 cflagsMacro.c_str () );
1224
1225         fprintf (
1226                 fMakefile,
1227                 "%s += $(PROJECT_RCFLAGS)\n",
1228                 windresflagsMacro.c_str () );
1229
1230         fprintf (
1231                 fMakefile,
1232                 "%s_LFLAGS += $(PROJECT_LFLAGS)\n",
1233                 module.name.c_str () );
1234
1235         fprintf (
1236                 fMakefile,
1237                 "%s += $(%s)\n",
1238                 linkDepsMacro.c_str (),
1239                 libsMacro.c_str () );
1240
1241         string cflags = TypeSpecificCFlags();
1242         if ( cflags.size() > 0 )
1243         {
1244                 fprintf ( fMakefile,
1245                           "%s += %s\n\n",
1246                           cflagsMacro.c_str (),
1247                           cflags.c_str () );
1248         }
1249
1250         string nasmflags = TypeSpecificNasmFlags();
1251         if ( nasmflags.size () > 0 )
1252         {
1253                 fprintf ( fMakefile,
1254                           "%s += %s\n\n",
1255                           nasmflagsMacro.c_str (),
1256                           nasmflags.c_str () );
1257         }
1258
1259         fprintf ( fMakefile, "\n\n" );
1260
1261         // future references to the macros will be to get their values
1262         cflagsMacro = ssprintf ("$(%s)", cflagsMacro.c_str ());
1263         nasmflagsMacro = ssprintf ("$(%s)", nasmflagsMacro.c_str ());
1264 }
1265
1266 void
1267 MingwModuleHandler::GenerateRules ()
1268 {
1269         string cc = ( module.host == HostTrue ? "${host_gcc}" : "${gcc}" );
1270         string cppc = ( module.host == HostTrue ? "${host_gpp}" : "${gpp}" );
1271         string ar = ( module.host == HostTrue ? "${host_ar}" : "${ar}" );
1272
1273         string targetMacro = GetTargetMacro ( module );
1274
1275         CLEAN_FILE ( targetMacro );
1276
1277         // generate phony target for module name
1278         fprintf ( fMakefile, ".PHONY: %s\n",
1279                 module.name.c_str () );
1280         fprintf ( fMakefile, "%s: %s\n\n",
1281                 module.name.c_str (),
1282                 GetTargetMacro ( module ).c_str () );
1283
1284         string ar_target;
1285         if ( module.type != ObjectLibrary )
1286                 ar_target = GenerateArchiveTarget ( ar, objectsMacro );
1287
1288         GenerateObjectFileTargets ( cc,
1289                                                                 cppc,
1290                                                                 cflagsMacro,
1291                                                                 nasmflagsMacro,
1292                                                                 windresflagsMacro );
1293
1294         if ( module.type != ObjectLibrary )
1295         {
1296                 if ( targetMacro != ar_target )
1297                 {
1298                         CLEAN_FILE ( ar_target );
1299                 }
1300         }
1301 }
1302
1303 void
1304 MingwModuleHandler::GetInvocationDependencies (
1305         const Module& module,
1306         string_list& dependencies )
1307 {
1308         for ( size_t i = 0; i < module.invocations.size (); i++ )
1309         {
1310                 Invoke& invoke = *module.invocations[i];
1311                 if ( invoke.invokeModule == &module )
1312                         /* Protect against circular dependencies */
1313                         continue;
1314                 invoke.GetTargets ( dependencies );
1315         }
1316 }
1317
1318 void
1319 MingwModuleHandler::GenerateInvocations () const
1320 {
1321         if ( module.invocations.size () == 0 )
1322                 return;
1323
1324         size_t iend = module.invocations.size ();
1325         for ( size_t i = 0; i < iend; i++ )
1326         {
1327                 const Invoke& invoke = *module.invocations[i];
1328
1329                 if ( invoke.invokeModule->type != BuildTool )
1330                 {
1331                         throw InvalidBuildFileException ( module.node.location,
1332                                                           "Only modules of type buildtool can be invoked." );
1333                 }
1334
1335                 string invokeTarget = module.GetInvocationTarget ( i );
1336                 string_list invoke_targets;
1337                 assert ( invoke_targets.size() );
1338                 invoke.GetTargets ( invoke_targets );
1339                 fprintf ( fMakefile,
1340                           ".PHONY: %s\n\n",
1341                           invokeTarget.c_str () );
1342                 fprintf ( fMakefile,
1343                           "%s:",
1344                           invokeTarget.c_str () );
1345                 size_t j, jend = invoke_targets.size();
1346                 for ( j = 0; j < jend; j++ )
1347                 {
1348                         fprintf ( fMakefile,
1349                                   " %s",
1350                                   invoke_targets[i].c_str () );
1351                 }
1352                 fprintf ( fMakefile, "\n\n%s", invoke_targets[0].c_str () );
1353                 for ( j = 1; j < jend; j++ )
1354                         fprintf ( fMakefile,
1355                                   " %s",
1356                                   invoke_targets[i].c_str () );
1357                 fprintf ( fMakefile,
1358                           ": %s\n",
1359                           FixupTargetFilename ( invoke.invokeModule->GetPath () ).c_str () );
1360                 fprintf ( fMakefile, "\t$(ECHO_INVOKE)\n" );
1361                 fprintf ( fMakefile,
1362                           "\t%s %s\n\n",
1363                           FixupTargetFilename ( invoke.invokeModule->GetPath () ).c_str (),
1364                           invoke.GetParameters ().c_str () );
1365         }
1366 }
1367
1368 string
1369 MingwModuleHandler::GetPreconditionDependenciesName () const
1370 {
1371         return module.name + "_precondition";
1372 }
1373
1374 void
1375 MingwModuleHandler::GetDefaultDependencies (
1376         string_list& dependencies ) const
1377 {
1378         /* Avoid circular dependency */
1379         if ( module.type != BuildTool
1380                 && module.name != "zlib"
1381                 && module.name != "hostzlib" )
1382
1383                 dependencies.push_back ( "$(INIT)" );
1384 }
1385
1386 void
1387 MingwModuleHandler::GeneratePreconditionDependencies ()
1388 {
1389         string preconditionDependenciesName = GetPreconditionDependenciesName ();
1390         string_list sourceFilenames;
1391         GetSourceFilenamesWithoutGeneratedFiles ( sourceFilenames );
1392         string_list dependencies;
1393         GetDefaultDependencies ( dependencies );
1394         GetModuleDependencies ( dependencies );
1395
1396         GetInvocationDependencies ( module, dependencies );
1397
1398         if ( dependencies.size() )
1399         {
1400                 fprintf ( fMakefile,
1401                           "%s =",
1402                           preconditionDependenciesName.c_str () );
1403                 for ( size_t i = 0; i < dependencies.size(); i++ )
1404                         fprintf ( fMakefile,
1405                                   " %s",
1406                                   dependencies[i].c_str () );
1407                 fprintf ( fMakefile, "\n\n" );
1408         }
1409
1410         for ( size_t i = 0; i < sourceFilenames.size(); i++ )
1411         {
1412                 fprintf ( fMakefile,
1413                           "%s: ${%s}\n",
1414                           sourceFilenames[i].c_str(),
1415                           preconditionDependenciesName.c_str ());
1416         }
1417         fprintf ( fMakefile, "\n" );
1418 }
1419
1420 void
1421 MingwModuleHandler::GenerateImportLibraryTargetIfNeeded ()
1422 {
1423         if ( module.importLibrary != NULL )
1424         {
1425                 string library_target (
1426                         GetImportLibraryFilename ( module, &clean_files ) );
1427
1428                 string_list deps;
1429                 GetDefinitionDependencies ( deps );
1430
1431                 fprintf ( fMakefile, "# IMPORT LIBRARY RULE:\n" );
1432
1433                 fprintf ( fMakefile, "%s:",
1434                           library_target.c_str () );
1435
1436                 size_t i, iend = deps.size();
1437                 for ( i = 0; i < iend; i++ )
1438                         fprintf ( fMakefile, " %s",
1439                                   deps[i].c_str () );
1440
1441                 fprintf ( fMakefile, " %s\n",
1442                           GetDirectory(GetTargetFilename(module,NULL)).c_str () );
1443
1444                 fprintf ( fMakefile, "\t$(ECHO_DLLTOOL)\n" );
1445
1446                 string killAt = module.mangledSymbols ? "" : "--kill-at";
1447                 fprintf ( fMakefile,
1448                           "\t${dlltool} --dllname %s --def %s --output-lib %s %s\n\n",
1449                           module.GetTargetName ().c_str (),
1450                           ( module.GetBasePath () + SSEP + module.importLibrary->definition ).c_str (),
1451                           library_target.c_str (),
1452                           killAt.c_str () );
1453         }
1454 }
1455
1456 void
1457 MingwModuleHandler::GetSpecObjectDependencies (
1458         string_list& dependencies,
1459         const string& filename ) const
1460 {
1461         string basename = GetBasename ( filename );
1462         dependencies.push_back ( basename + ".spec.def" );
1463         dependencies.push_back ( basename + ".stubs.c" );
1464 }
1465
1466 void
1467 MingwModuleHandler::GetDefinitionDependencies (
1468         string_list& dependencies ) const
1469 {
1470         string dkNkmLibNoFixup = "dk/nkm/lib";
1471         // TODO FIXME - verify this is the correct dependency...
1472         // easiest way to tell is to remove it and see what breaks
1473         /*dependencies += PassThruCacheDirectory (
1474                 FixupTargetFilename ( dkNkmLibNoFixup ),
1475                 false, NULL );*/
1476         const vector<File*>& files = module.non_if_data.files;
1477         for ( size_t i = 0; i < files.size (); i++ )
1478         {
1479                 File& file = *files[i];
1480                 string extension = GetExtension ( file.name );
1481                 if ( extension == ".spec" || extension == ".SPEC" )
1482                 {
1483                         GetSpecObjectDependencies ( dependencies, file.name );
1484                 }
1485         }
1486 }
1487
1488 MingwBuildToolModuleHandler::MingwBuildToolModuleHandler ( const Module& module_ )
1489         : MingwModuleHandler ( module_ )
1490 {
1491 }
1492
1493 void
1494 MingwBuildToolModuleHandler::Process ()
1495 {
1496         GenerateBuildToolModuleTarget ();
1497 }
1498
1499 void
1500 MingwBuildToolModuleHandler::GenerateBuildToolModuleTarget ()
1501 {
1502         string targetMacro ( GetTargetMacro (module) );
1503         string objectsMacro = GetObjectsMacro ( module );
1504         string linkDepsMacro = GetLinkingDependenciesMacro ();
1505         string libsMacro = GetLibsMacro ();
1506
1507         GenerateRules ();
1508
1509         string linker;
1510         if ( module.cplusplus )
1511                 linker = "${host_gpp}";
1512         else
1513                 linker = "${host_gcc}";
1514
1515         fprintf ( fMakefile, "%s: %s %s %s\n",
1516                   targetMacro.c_str (),
1517                   objectsMacro.c_str (),
1518                   linkDepsMacro.c_str (),
1519                   GetDirectory(GetTargetFilename(module,NULL)).c_str () );
1520         fprintf ( fMakefile, "\t$(ECHO_LD)\n" );
1521         fprintf ( fMakefile,
1522                   "\t%s %s -o $@ %s %s\n\n",
1523                   linker.c_str (),
1524                   GetLinkerMacro ().c_str (),
1525                   objectsMacro.c_str (),
1526                   libsMacro.c_str () );
1527 }
1528
1529
1530 MingwKernelModuleHandler::MingwKernelModuleHandler (
1531         const Module& module_ )
1532
1533         : MingwModuleHandler ( module_ )
1534 {
1535 }
1536
1537 void
1538 MingwKernelModuleHandler::Process ()
1539 {
1540         GenerateKernelModuleTarget ();
1541 }
1542
1543 void
1544 MingwKernelModuleHandler::GenerateKernelModuleTarget ()
1545 {
1546         string targetName ( module.GetTargetName () ); // i.e. "ntoskrnl.exe"
1547         string targetMacro ( GetTargetMacro (module) ); // i.e. "$(NTOSKRNL_TARGET)"
1548         string workingDirectory = GetWorkingDirectory ();
1549         string objectsMacro = GetObjectsMacro ( module );
1550         string linkDepsMacro = GetLinkingDependenciesMacro ();
1551         string libsMacro = GetLibsMacro ();
1552         string base_tmp = ros_temp + module.name + ".base.tmp";
1553         CLEAN_FILE ( base_tmp );
1554         string junk_tmp = ros_temp + module.name + ".junk.tmp";
1555         CLEAN_FILE ( junk_tmp );
1556         string temp_exp = ros_temp + module.name + ".temp.exp";
1557         CLEAN_FILE ( temp_exp );
1558         string gccOptions = ssprintf ("-Wl,-T,%s" SSEP "ntoskrnl.lnk -Wl,--subsystem,native -Wl,--entry,%s -Wl,--image-base,%s -Wl,--file-alignment,0x1000 -Wl,--section-alignment,0x1000 -nostartfiles -mdll",
1559                                       module.GetBasePath ().c_str (),
1560                                       module.entrypoint.c_str (),
1561                                       module.baseaddress.c_str () );
1562
1563         GenerateRules ();
1564
1565         GenerateImportLibraryTargetIfNeeded ();
1566
1567         fprintf ( fMakefile, "%s: %s %s %s $(RSYM_TARGET)\n",
1568                   targetMacro.c_str (),
1569                   objectsMacro.c_str (),
1570                   linkDepsMacro.c_str (),
1571                   GetDirectory(GetTargetFilename(module,NULL)).c_str () );
1572         fprintf ( fMakefile, "\t$(ECHO_LD)\n" );
1573         fprintf ( fMakefile,
1574                   "\t${gcc} %s %s -Wl,--base-file,%s -o %s %s %s\n",
1575                   GetLinkerMacro ().c_str (),
1576                   gccOptions.c_str (),
1577                   base_tmp.c_str (),
1578                   junk_tmp.c_str (),
1579                   objectsMacro.c_str (),
1580                   linkDepsMacro.c_str () );
1581         fprintf ( fMakefile,
1582                   "\t-@${rm} %s 2>$(NUL)\n",
1583                   junk_tmp.c_str () );
1584         string killAt = module.mangledSymbols ? "" : "--kill-at";
1585         fprintf ( fMakefile,
1586                   "\t${dlltool} --dllname %s --base-file %s --def ntoskrnl/ntoskrnl.def --output-exp %s %s\n",
1587                   targetName.c_str (),
1588                   base_tmp.c_str (),
1589                   temp_exp.c_str (),
1590                   killAt.c_str () );
1591         fprintf ( fMakefile,
1592                   "\t-@${rm} %s 2>$(NUL)\n",
1593                   base_tmp.c_str () );
1594         fprintf ( fMakefile,
1595                   "\t${gcc} %s %s -Wl,%s -o $@ %s %s\n",
1596                   GetLinkerMacro ().c_str (),
1597                   gccOptions.c_str (),
1598                   temp_exp.c_str (),
1599                   objectsMacro.c_str (),
1600                   linkDepsMacro.c_str () );
1601         fprintf ( fMakefile,
1602                   "\t-@${rm} %s 2>$(NUL)\n",
1603                   temp_exp.c_str () );
1604         fprintf ( fMakefile, "\t$(ECHO_RSYM)\n" );
1605         fprintf ( fMakefile,
1606                   "\t$(Q)$(RSYM_TARGET) $@ $@\n\n" );
1607 }
1608
1609
1610 MingwStaticLibraryModuleHandler::MingwStaticLibraryModuleHandler (
1611         const Module& module_ )
1612
1613         : MingwModuleHandler ( module_ )
1614 {
1615 }
1616
1617 void
1618 MingwStaticLibraryModuleHandler::Process ()
1619 {
1620         GenerateStaticLibraryModuleTarget ();
1621 }
1622
1623 void
1624 MingwStaticLibraryModuleHandler::GenerateStaticLibraryModuleTarget ()
1625 {
1626         GenerateRules ();
1627 }
1628
1629
1630 MingwObjectLibraryModuleHandler::MingwObjectLibraryModuleHandler (
1631         const Module& module_ )
1632
1633         : MingwModuleHandler ( module_ )
1634 {
1635 }
1636
1637 void
1638 MingwObjectLibraryModuleHandler::Process ()
1639 {
1640         GenerateObjectLibraryModuleTarget ();
1641 }
1642
1643 void
1644 MingwObjectLibraryModuleHandler::GenerateObjectLibraryModuleTarget ()
1645 {
1646         GenerateRules ();
1647 }
1648
1649
1650 MingwKernelModeDLLModuleHandler::MingwKernelModeDLLModuleHandler (
1651         const Module& module_ )
1652
1653         : MingwModuleHandler ( module_ )
1654 {
1655 }
1656
1657 void
1658 MingwKernelModeDLLModuleHandler::Process ()
1659 {
1660         GenerateKernelModeDLLModuleTarget ();
1661 }
1662
1663 void
1664 MingwKernelModeDLLModuleHandler::GenerateKernelModeDLLModuleTarget ()
1665 {
1666         string targetMacro ( GetTargetMacro (module) );
1667         string workingDirectory = GetWorkingDirectory ( );
1668         string objectsMacro = GetObjectsMacro ( module );
1669         string linkDepsMacro = GetLinkingDependenciesMacro ();
1670         string libsMacro = GetLibsMacro ();
1671
1672         GenerateImportLibraryTargetIfNeeded ();
1673
1674         if ( module.non_if_data.files.size () > 0 )
1675         {
1676                 GenerateRules ();
1677
1678                 string dependencies =
1679                         objectsMacro + " " + linkDepsMacro;
1680
1681                 string linkerParameters = ssprintf ( "-Wl,--subsystem,native -Wl,--entry,%s -Wl,--image-base,%s -Wl,--file-alignment,0x1000 -Wl,--section-alignment,0x1000 -nostartfiles -mdll",
1682                                                      module.entrypoint.c_str (),
1683                                                      module.baseaddress.c_str () );
1684                 GenerateLinkerCommand ( dependencies,
1685                                         "${gcc}",
1686                                         linkerParameters,
1687                                         objectsMacro,
1688                                         libsMacro );
1689         }
1690         else
1691         {
1692                 GeneratePhonyTarget();
1693         }
1694 }
1695
1696
1697 MingwKernelModeDriverModuleHandler::MingwKernelModeDriverModuleHandler (
1698         const Module& module_ )
1699
1700         : MingwModuleHandler ( module_ )
1701 {
1702 }
1703
1704 void
1705 MingwKernelModeDriverModuleHandler::Process ()
1706 {
1707         GenerateKernelModeDriverModuleTarget ();
1708 }
1709
1710
1711 void
1712 MingwKernelModeDriverModuleHandler::GenerateKernelModeDriverModuleTarget ()
1713 {
1714         string targetMacro ( GetTargetMacro (module) );
1715         string workingDirectory = GetWorkingDirectory ();
1716         string objectsMacro = GetObjectsMacro ( module );
1717         string linkDepsMacro = GetLinkingDependenciesMacro ();
1718         string libsMacro = GetLibsMacro ();
1719
1720         GenerateImportLibraryTargetIfNeeded ();
1721
1722         if ( module.non_if_data.files.size () > 0 )
1723         {
1724                 GenerateRules ();
1725
1726                 string dependencies = objectsMacro + " " + linkDepsMacro;
1727
1728                 string linkerParameters = ssprintf ( "-Wl,--subsystem,native -Wl,--entry,%s -Wl,--image-base,%s -Wl,--file-alignment,0x1000 -Wl,--section-alignment,0x1000 -nostartfiles -mdll",
1729                                                      module.entrypoint.c_str (),
1730                                                      module.baseaddress.c_str () );
1731                 GenerateLinkerCommand ( dependencies,
1732                                         "${gcc}",
1733                                         linkerParameters,
1734                                         objectsMacro,
1735                                         libsMacro );
1736         }
1737         else
1738         {
1739                 GeneratePhonyTarget();
1740         }
1741 }
1742
1743
1744 MingwNativeDLLModuleHandler::MingwNativeDLLModuleHandler (
1745         const Module& module_ )
1746
1747         : MingwModuleHandler ( module_ )
1748 {
1749 }
1750
1751 void
1752 MingwNativeDLLModuleHandler::Process ()
1753 {
1754         GenerateNativeDLLModuleTarget ();
1755 }
1756
1757 void
1758 MingwNativeDLLModuleHandler::GenerateNativeDLLModuleTarget ()
1759 {
1760         string targetMacro ( GetTargetMacro (module) );
1761         string workingDirectory = GetWorkingDirectory ( );
1762         string objectsMacro = GetObjectsMacro ( module );
1763         string linkDepsMacro = GetLinkingDependenciesMacro ();
1764         string libsMacro = GetLibsMacro ();
1765
1766         GenerateImportLibraryTargetIfNeeded ();
1767
1768         if ( module.non_if_data.files.size () > 0 )
1769         {
1770                 GenerateRules ();
1771
1772                 string dependencies =
1773                         objectsMacro + " " + linkDepsMacro;
1774
1775                 string linkerParameters = ssprintf ( "-Wl,--subsystem,native -Wl,--entry,%s -Wl,--image-base,%s -Wl,--file-alignment,0x1000 -Wl,--section-alignment,0x1000 -nostartfiles -nostdlib -mdll",
1776                                                      module.entrypoint.c_str (),
1777                                                      module.baseaddress.c_str () );
1778                 GenerateLinkerCommand ( dependencies,
1779                                         "${gcc}",
1780                                         linkerParameters,
1781                                         objectsMacro,
1782                                         libsMacro );
1783         }
1784         else
1785         {
1786                 GeneratePhonyTarget();
1787         }
1788 }
1789
1790
1791 MingwNativeCUIModuleHandler::MingwNativeCUIModuleHandler (
1792         const Module& module_ )
1793
1794         : MingwModuleHandler ( module_ )
1795 {
1796 }
1797
1798 void
1799 MingwNativeCUIModuleHandler::Process ()
1800 {
1801         GenerateNativeCUIModuleTarget ();
1802 }
1803
1804 void
1805 MingwNativeCUIModuleHandler::GenerateNativeCUIModuleTarget ()
1806 {
1807         string targetMacro ( GetTargetMacro (module) );
1808         string workingDirectory = GetWorkingDirectory ( );
1809         string objectsMacro = GetObjectsMacro ( module );
1810         string linkDepsMacro = GetLinkingDependenciesMacro ();
1811         string libsMacro = GetLibsMacro ();
1812
1813         GenerateImportLibraryTargetIfNeeded ();
1814
1815         if ( module.non_if_data.files.size () > 0 )
1816         {
1817                 GenerateRules ();
1818
1819                 string dependencies =
1820                         objectsMacro + " " + linkDepsMacro;
1821
1822                 string linkerParameters = ssprintf ( "-Wl,--subsystem,native -Wl,--entry,%s -Wl,--image-base,%s -Wl,--file-alignment,0x1000 -Wl,--section-alignment,0x1000 -nostartfiles -nostdlib",
1823                                                      module.entrypoint.c_str (),
1824                                                      module.baseaddress.c_str () );
1825                 GenerateLinkerCommand ( dependencies,
1826                                         "${gcc}",
1827                                         linkerParameters,
1828                                         objectsMacro,
1829                                         libsMacro );
1830         }
1831         else
1832         {
1833                 GeneratePhonyTarget();
1834         }
1835 }
1836
1837
1838 MingwWin32DLLModuleHandler::MingwWin32DLLModuleHandler (
1839         const Module& module_ )
1840
1841         : MingwModuleHandler ( module_ )
1842 {
1843 }
1844
1845 void
1846 MingwWin32DLLModuleHandler::Process ()
1847 {
1848         GenerateExtractWineDLLResourcesTarget ();
1849         GenerateWin32DLLModuleTarget ();
1850 }
1851
1852 void
1853 MingwWin32DLLModuleHandler::GenerateExtractWineDLLResourcesTarget ()
1854 {
1855         fprintf ( fMakefile, ".PHONY: %s_extractresources\n\n",
1856                   module.name.c_str () );
1857         fprintf ( fMakefile, "%s_extractresources: $(BIN2RES_TARGET)\n",
1858                   module.name.c_str () );
1859         const vector<File*>& files = module.non_if_data.files;
1860         for ( size_t i = 0; i < files.size (); i++ )
1861         {
1862                 File& file = *files[i];
1863                 string extension = GetExtension ( file.name );
1864                 if ( extension == ".rc" || extension == ".RC" )
1865                 {
1866                         string resource = FixupTargetFilename ( file.name );
1867                         fprintf ( fMakefile, "\t$(ECHO_BIN2RES)\n" );
1868                         fprintf ( fMakefile, "\t@:echo ${bin2res} -f -x %s\n",
1869                                   resource.c_str () );
1870                 }
1871         }
1872         fprintf ( fMakefile, "\n");
1873 }
1874
1875 void
1876 MingwWin32DLLModuleHandler::GenerateWin32DLLModuleTarget ()
1877 {
1878         string targetMacro ( GetTargetMacro (module) );
1879         string workingDirectory = GetWorkingDirectory ( );
1880         string objectsMacro = GetObjectsMacro ( module );
1881         string linkDepsMacro = GetLinkingDependenciesMacro ();
1882         string libsMacro = GetLibsMacro ();
1883
1884         GenerateImportLibraryTargetIfNeeded ();
1885
1886         if ( module.non_if_data.files.size () > 0 )
1887         {
1888                 GenerateRules ();
1889
1890                 string dependencies = objectsMacro + " " + linkDepsMacro;
1891
1892                 string linker;
1893                 if ( module.cplusplus )
1894                         linker = "${gpp}";
1895                 else
1896                         linker = "${gcc}";
1897
1898                 string linkerParameters = ssprintf ( "-Wl,--subsystem,console -Wl,--entry,%s -Wl,--image-base,%s -Wl,--file-alignment,0x1000 -Wl,--section-alignment,0x1000 -mdll",
1899                                                      module.entrypoint.c_str (),
1900                                                      module.baseaddress.c_str () );
1901                 GenerateLinkerCommand ( dependencies,
1902                                         linker,
1903                                         linkerParameters,
1904                                         objectsMacro,
1905                                         libsMacro );
1906         }
1907         else
1908         {
1909                 GeneratePhonyTarget();
1910         }
1911 }
1912
1913
1914 MingwWin32CUIModuleHandler::MingwWin32CUIModuleHandler (
1915         const Module& module_ )
1916
1917         : MingwModuleHandler ( module_ )
1918 {
1919 }
1920
1921 void
1922 MingwWin32CUIModuleHandler::Process ()
1923 {
1924         GenerateWin32CUIModuleTarget ();
1925 }
1926
1927 void
1928 MingwWin32CUIModuleHandler::GenerateWin32CUIModuleTarget ()
1929 {
1930         string targetMacro ( GetTargetMacro (module) );
1931         string workingDirectory = GetWorkingDirectory ( );
1932         string objectsMacro = GetObjectsMacro ( module );
1933         string linkDepsMacro = GetLinkingDependenciesMacro ();
1934         string libsMacro = GetLibsMacro ();
1935
1936         GenerateImportLibraryTargetIfNeeded ();
1937
1938         if ( module.non_if_data.files.size () > 0 )
1939         {
1940                 GenerateRules ();
1941
1942                 string dependencies =
1943                         objectsMacro + " " + linkDepsMacro;
1944
1945                 string linker;
1946                 if ( module.cplusplus )
1947                         linker = "${gpp}";
1948                 else
1949                         linker = "${gcc}";
1950
1951                 string linkerParameters = ssprintf ( "-Wl,--subsystem,console -Wl,--entry,%s -Wl,--image-base,%s -Wl,--file-alignment,0x1000 -Wl,--section-alignment,0x1000",
1952                                                      module.entrypoint.c_str (),
1953                                                      module.baseaddress.c_str () );
1954                 GenerateLinkerCommand ( dependencies,
1955                                         linker,
1956                                         linkerParameters,
1957                                         objectsMacro,
1958                                         libsMacro );
1959         }
1960         else
1961         {
1962                 GeneratePhonyTarget();
1963         }
1964 }
1965
1966
1967 MingwWin32GUIModuleHandler::MingwWin32GUIModuleHandler (
1968         const Module& module_ )
1969
1970         : MingwModuleHandler ( module_ )
1971 {
1972 }
1973
1974 void
1975 MingwWin32GUIModuleHandler::Process ()
1976 {
1977         GenerateWin32GUIModuleTarget ();
1978 }
1979
1980 void
1981 MingwWin32GUIModuleHandler::GenerateWin32GUIModuleTarget ()
1982 {
1983         string targetMacro ( GetTargetMacro (module) );
1984         string workingDirectory = GetWorkingDirectory ( );
1985         string objectsMacro = GetObjectsMacro ( module );
1986         string linkDepsMacro = GetLinkingDependenciesMacro ();
1987         string libsMacro = GetLibsMacro ();
1988
1989         GenerateImportLibraryTargetIfNeeded ();
1990
1991         if ( module.non_if_data.files.size () > 0 )
1992         {
1993                 GenerateRules ();
1994
1995                 string dependencies =
1996                         objectsMacro + " " + linkDepsMacro;
1997
1998                 string linker;
1999                 if ( module.cplusplus )
2000                         linker = "${gpp}";
2001                 else
2002                         linker = "${gcc}";
2003
2004                 string linkerParameters = ssprintf ( "-Wl,--subsystem,windows -Wl,--entry,%s -Wl,--image-base,%s -Wl,--file-alignment,0x1000 -Wl,--section-alignment,0x1000",
2005                                                      module.entrypoint.c_str (),
2006                                                      module.baseaddress.c_str () );
2007                 GenerateLinkerCommand ( dependencies,
2008                                         linker,
2009                                         linkerParameters,
2010                                         objectsMacro,
2011                                         libsMacro );
2012         }
2013         else
2014         {
2015                 GeneratePhonyTarget();
2016         }
2017 }
2018
2019
2020 MingwBootLoaderModuleHandler::MingwBootLoaderModuleHandler (
2021         const Module& module_ )
2022
2023         : MingwModuleHandler ( module_ )
2024 {
2025 }
2026
2027 void
2028 MingwBootLoaderModuleHandler::Process ()
2029 {
2030         GenerateBootLoaderModuleTarget ();
2031 }
2032
2033 void
2034 MingwBootLoaderModuleHandler::GenerateBootLoaderModuleTarget ()
2035 {
2036         string targetName ( module.GetTargetName () );
2037         string targetMacro ( GetTargetMacro (module) );
2038         string workingDirectory = GetWorkingDirectory ();
2039         string junk_tmp = ros_temp + module.name + ".junk.tmp";
2040         CLEAN_FILE ( junk_tmp );
2041         string objectsMacro = GetObjectsMacro ( module );
2042         string linkDepsMacro = GetLinkingDependenciesMacro ();
2043         string libsMacro = GetLibsMacro ();
2044
2045         GenerateRules ();
2046
2047         fprintf ( fMakefile, "%s: %s %s %s\n",
2048                   targetMacro.c_str (),
2049                   objectsMacro.c_str (),
2050                   linkDepsMacro.c_str (),
2051                   GetDirectory(GetTargetFilename(module,NULL)).c_str () );
2052
2053         fprintf ( fMakefile, "\t$(ECHO_LD)\n" );
2054
2055         fprintf ( fMakefile,
2056                   "\t${ld} %s -N -Ttext=0x8000 -o %s %s %s\n",
2057                   GetLinkerMacro ().c_str (),
2058                   junk_tmp.c_str (),
2059                   objectsMacro.c_str (),
2060                   linkDepsMacro.c_str () );
2061         fprintf ( fMakefile,
2062                   "\t${objcopy} -O binary %s $@\n",
2063                   junk_tmp.c_str () );
2064         fprintf ( fMakefile,
2065                   "\t-@${rm} %s 2>$(NUL)\n",
2066                   junk_tmp.c_str () );
2067 }
2068
2069
2070 MingwBootSectorModuleHandler::MingwBootSectorModuleHandler (
2071         const Module& module_ )
2072
2073         : MingwModuleHandler ( module_ )
2074 {
2075 }
2076
2077 void
2078 MingwBootSectorModuleHandler::Process ()
2079 {
2080         GenerateBootSectorModuleTarget ();
2081 }
2082
2083 void
2084 MingwBootSectorModuleHandler::GenerateBootSectorModuleTarget ()
2085 {
2086         string objectsMacro = GetObjectsMacro ( module );
2087
2088         GenerateRules ();
2089
2090         fprintf ( fMakefile, ".PHONY: %s\n\n",
2091                   module.name.c_str ());
2092         fprintf ( fMakefile,
2093                   "%s: %s\n",
2094                   module.name.c_str (),
2095                   objectsMacro.c_str () );
2096 }
2097
2098
2099 MingwIsoModuleHandler::MingwIsoModuleHandler (
2100         const Module& module_ )
2101
2102         : MingwModuleHandler ( module_ )
2103 {
2104 }
2105
2106 void
2107 MingwIsoModuleHandler::Process ()
2108 {
2109         GenerateIsoModuleTarget ();
2110 }
2111
2112 void
2113 MingwIsoModuleHandler::OutputBootstrapfileCopyCommands (
2114         const string& bootcdDirectory )
2115 {
2116         for ( size_t i = 0; i < module.project.modules.size (); i++ )
2117         {
2118                 const Module& m = *module.project.modules[i];
2119                 if ( m.bootstrap != NULL )
2120                 {
2121                         string targetFilenameNoFixup ( bootcdDirectory + SSEP + m.bootstrap->base + SSEP + m.bootstrap->nameoncd );
2122                         string targetFilename ( GetTargetMacro ( module ) );
2123                         fprintf ( fMakefile,
2124                                   "\t${cp} %s %s\n",
2125                                   m.GetPath ().c_str (),
2126                                   targetFilename.c_str () );
2127                 }
2128         }
2129 }
2130
2131 void
2132 MingwIsoModuleHandler::OutputCdfileCopyCommands (
2133         const string& bootcdDirectory )
2134 {
2135         for ( size_t i = 0; i < module.project.cdfiles.size (); i++ )
2136         {
2137                 const CDFile& cdfile = *module.project.cdfiles[i];
2138                 string targetFilenameNoFixup = bootcdDirectory + SSEP + cdfile.base + SSEP + cdfile.nameoncd;
2139                 string targetFilename = GetTargetMacro(module);
2140                 fprintf ( fMakefile,
2141                           "\t${cp} %s %s\n",
2142                           cdfile.GetPath ().c_str (),
2143                           targetFilename.c_str () );
2144         }
2145 }
2146
2147 string
2148 MingwIsoModuleHandler::GetBootstrapCdDirectories ( const string& bootcdDirectory )
2149 {
2150         string directories;
2151         for ( size_t i = 0; i < module.project.modules.size (); i++ )
2152         {
2153                 const Module& m = *module.project.modules[i];
2154                 if ( m.bootstrap != NULL )
2155                 {
2156                         string targetDirectory ( bootcdDirectory + SSEP + m.bootstrap->base );
2157                         if ( directories.size () > 0 )
2158                                 directories += " ";
2159                         directories += PassThruCacheDirectory (
2160                                 FixupTargetFilename ( targetDirectory ),
2161                                 true );
2162                 }
2163         }
2164         return directories;
2165 }
2166
2167 string
2168 MingwIsoModuleHandler::GetNonModuleCdDirectories ( const string& bootcdDirectory )
2169 {
2170         string directories;
2171         for ( size_t i = 0; i < module.project.cdfiles.size (); i++ )
2172         {
2173                 const CDFile& cdfile = *module.project.cdfiles[i];
2174                 string targetDirectory ( bootcdDirectory + SSEP + cdfile.base );
2175                 if ( directories.size () > 0 )
2176                         directories += " ";
2177                 directories += PassThruCacheDirectory (
2178                         FixupTargetFilename ( targetDirectory ),
2179                         true );
2180         }
2181         return directories;
2182 }
2183
2184 string
2185 MingwIsoModuleHandler::GetCdDirectories ( const string& bootcdDirectory )
2186 {
2187         string directories = GetBootstrapCdDirectories ( bootcdDirectory );
2188         directories += " " + GetNonModuleCdDirectories ( bootcdDirectory );
2189         return directories;
2190 }
2191
2192 void
2193 MingwIsoModuleHandler::GetBootstrapCdFiles (
2194         vector<string>& out ) const
2195 {
2196         for ( size_t i = 0; i < module.project.modules.size (); i++ )
2197         {
2198                 const Module& m = *module.project.modules[i];
2199                 if ( m.bootstrap != NULL )
2200                         out.push_back ( FixupTargetFilename ( m.GetPath () ) );
2201         }
2202 }
2203
2204 void
2205 MingwIsoModuleHandler::GetNonModuleCdFiles (
2206         vector<string>& out ) const
2207 {
2208         for ( size_t i = 0; i < module.project.cdfiles.size (); i++ )
2209         {
2210                 const CDFile& cdfile = *module.project.cdfiles[i];
2211                 out.push_back ( NormalizeFilename ( cdfile.GetPath () ) );
2212         }
2213 }
2214
2215 void
2216 MingwIsoModuleHandler::GetCdFiles (
2217         vector<string>& out ) const
2218 {
2219         GetBootstrapCdFiles ( out );
2220         GetNonModuleCdFiles ( out );
2221 }
2222
2223 void
2224 MingwIsoModuleHandler::GenerateIsoModuleTarget ()
2225 {
2226         string bootcdDirectory = "cd";
2227         string isoboot = FixupTargetFilename ( "boot/freeldr/bootsect/isoboot.o" );
2228         string bootcdReactosNoFixup = bootcdDirectory + "/reactos";
2229         string bootcdReactos = PassThruCacheDirectory (
2230                 FixupTargetFilename ( bootcdReactosNoFixup ),
2231                 true );
2232         CLEAN_FILE ( bootcdReactos );
2233         string reactosInf = ros_temp + FixupTargetFilename ( bootcdReactosNoFixup + "/reactos.inf" );
2234         string reactosDff = NormalizeFilename ( "bootdata/packages/reactos.dff" );
2235         string cdDirectories = GetCdDirectories ( bootcdDirectory );
2236         vector<string> vCdFiles;
2237         GetCdFiles ( vCdFiles );
2238         string cdFiles = v2s ( vCdFiles, 5 );
2239
2240         fprintf ( fMakefile, ".PHONY: %s\n\n",
2241                   module.name.c_str ());
2242         fprintf ( fMakefile,
2243                   "%s: all %s %s %s %s $(CABMAN_TARGET) $(CDMAKE_TARGET)\n",
2244                   module.name.c_str (),
2245                   isoboot.c_str (),
2246                   bootcdReactos.c_str (),
2247                   cdDirectories.c_str (),
2248                   cdFiles.c_str () );
2249         fprintf ( fMakefile, "\t$(ECHO_CABMAN)\n" );
2250         fprintf ( fMakefile,
2251                   "\t$(Q)$(CABMAN_TARGET) -C %s -L %s -I\n",
2252                   reactosDff.c_str (),
2253                   bootcdReactos.c_str () );
2254         fprintf ( fMakefile,
2255                   "\t$(Q)$(CABMAN_TARGET) -C %s -RC %s -L %s -N -P $(OUTPUT)\n",
2256                   reactosDff.c_str (),
2257                   reactosInf.c_str (),
2258                   bootcdReactos.c_str ());
2259         fprintf ( fMakefile,
2260                   "\t-@${rm} %s 2>$(NUL)\n",
2261                   reactosInf.c_str () );
2262         OutputBootstrapfileCopyCommands ( bootcdDirectory );
2263         OutputCdfileCopyCommands ( bootcdDirectory );
2264         fprintf ( fMakefile, "\t$(ECHO_CDMAKE)\n" );
2265         fprintf ( fMakefile,
2266                   "\t$(Q)$(CDMAKE_TARGET) -v -m -b %s %s REACTOS ReactOS.iso\n",
2267                   isoboot.c_str (),
2268                   bootcdDirectory.c_str () );
2269         fprintf ( fMakefile,
2270                   "\n" );
2271 }
2272
2273
2274 MingwTestModuleHandler::MingwTestModuleHandler (
2275         const Module& module_ )
2276
2277         : MingwModuleHandler ( module_ )
2278 {
2279 }
2280
2281 void
2282 MingwTestModuleHandler::Process ()
2283 {
2284         GenerateTestModuleTarget ();
2285 }
2286
2287 void
2288 MingwTestModuleHandler::GenerateTestModuleTarget ()
2289 {
2290         string targetMacro ( GetTargetMacro (module) );
2291         string workingDirectory = GetWorkingDirectory ( );
2292         string objectsMacro = GetObjectsMacro ( module );
2293         string linkDepsMacro = GetLinkingDependenciesMacro ();
2294         string libsMacro = GetLibsMacro ();
2295
2296         GenerateImportLibraryTargetIfNeeded ();
2297
2298         if ( module.non_if_data.files.size () > 0 )
2299         {
2300                 GenerateRules ();
2301
2302                 string dependencies = objectsMacro + " " + linkDepsMacro;
2303
2304                 string linker;
2305                 if ( module.cplusplus )
2306                         linker = "${gpp}";
2307                 else
2308                         linker = "${gcc}";
2309
2310                 string linkerParameters = ssprintf ( "-Wl,--subsystem,console -Wl,--entry,%s -Wl,--image-base,%s -Wl,--file-alignment,0x1000 -Wl,--section-alignment,0x1000",
2311                                                      module.entrypoint.c_str (),
2312                                                      module.baseaddress.c_str () );
2313                 GenerateLinkerCommand ( dependencies,
2314                                         linker,
2315                                         linkerParameters,
2316                                         objectsMacro,
2317                                         libsMacro );
2318         }
2319         else
2320         {
2321                 GeneratePhonyTarget();
2322         }
2323 }