reactos/tools/rbuild/module.cpp

   1 /*
   2  * Copyright (C) 2005 Casper S. Hornstrup
   3  * Copyright (C) 2008 Hervé Poussineau
   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 #include <assert.h>
  21
  22 #include "rbuild.h"
  23
  24 using std::string;
  25 using std::vector;
  26
  27 string
  28 Right ( const string& s, size_t n )
  29 {
  30         if ( n > s.size() )
  31                 return s;
  32         return string ( &s[s.size()-n] );
  33 }
  34
  35 string
  36 Replace ( const string& s, const string& find, const string& with )
  37 {
  38         string ret;
  39         const char* p = s.c_str();
  40         while ( p )
  41         {
  42                 const char* p2 = strstr ( p, find.c_str() );
  43                 if ( !p2 )
  44                         break;
  45                 if ( p2 > p )
  46                         ret += string ( p, p2-p );
  47                 ret += with;
  48                 p = p2 + find.size();
  49         }
  50         if ( *p )
  51                 ret += p;
  52         return ret;
  53 }
  54
  55 string
  56 ChangeSeparator ( const string& s,
  57                   const char fromSeparator,
  58                   const char toSeparator )
  59 {
  60         string s2(s);
  61         char* p = strchr ( &s2[0], fromSeparator );
  62         while ( p )
  63         {
  64                 *p++ = toSeparator;
  65                 p = strchr ( p, fromSeparator );
  66         }
  67         return s2;
  68 }
  69
  70 string
  71 FixSeparator ( const string& s )
  72 {
  73         return ChangeSeparator ( s, cBadSep, cSep );
  74 }
  75
  76 string
  77 FixSeparatorForSystemCommand ( const string& s )
  78 {
  79         string s2(s);
  80         char* p = strchr ( &s2[0], DEF_CBAD_SEP );
  81         while ( p )
  82         {
  83                 *p++ = DEF_CSEP;
  84                 p = strchr ( p, DEF_CBAD_SEP );
  85         }
  86         return s2;
  87 }
  88
  89 string
  90 DosSeparator ( const string& s )
  91 {
  92         string s2(s);
  93         char* p = strchr ( &s2[0], '/' );
  94         while ( p )
  95         {
  96                 *p++ = '\\';
  97                 p = strchr ( p, '/' );
  98         }
  99         return s2;
 100 }
 101
 102 string
 103 ReplaceExtension (
 104         const string& filename,
 105         const string& newExtension )
 106 {
 107         size_t index = filename.find_last_of ( '/' );
 108         if ( index == string::npos )
 109                 index = 0;
 110         size_t index2 = filename.find_last_of ( '\\' );
 111         if ( index2 != string::npos && index2 > index )
 112                 index = index2;
 113         string tmp = filename.substr( index /*, filename.size() - index*/ );
 114         size_t ext_index = tmp.find_last_of( '.' );
 115         if ( ext_index != string::npos )
 116                 return filename.substr ( 0, index + ext_index ) + newExtension;
 117         return filename + newExtension;
 118 }
 119
 120 string
 121 GetSubPath (
 122         const Project& project,
 123         const string& location,
 124         const string& path,
 125         const string& att_value )
 126 {
 127         if ( !att_value.size() )
 128                 throw XMLInvalidBuildFileException (
 129                         location,
 130                         "<directory> tag has empty 'name' attribute" );
 131         if ( strpbrk ( att_value.c_str (), "/\\?*:<>|" ) )
 132                 throw XMLInvalidBuildFileException (
 133                         location,
 134                         "<directory> tag has invalid characters in 'name' attribute" );
 135         if ( !path.size() )
 136                 return att_value;
 137
 138         return FixSeparator(path + cSep + att_value);
 139 }
 140
 141 static string
 142 GetExtension ( const string& filename )
 143 {
 144         size_t index = filename.find_last_of ( '/' );
 145         if (index == string::npos) index = 0;
 146         string tmp = filename.substr( index, filename.size() - index );
 147         size_t ext_index = tmp.find_last_of( '.' );
 148         if (ext_index != string::npos)
 149                 return filename.substr ( index + ext_index, filename.size() );
 150         return "";
 151 }
 152
 153 string
 154 GetExtension ( const FileLocation& file )
 155 {
 156         return GetExtension ( file.name );
 157 }
 158
 159 string
 160 NormalizeFilename ( const string& filename )
 161 {
 162         if ( filename == "" )
 163                 return "";
 164         Path path;
 165         string normalizedPath = path.Fixup ( filename, true );
 166         string relativeNormalizedPath = path.RelativeFromWorkingDirectory ( normalizedPath );
 167         return FixSeparator ( relativeNormalizedPath );
 168 }
 169
 170 bool
 171 GetBooleanValue ( const string& value )
 172 {
 173         if ( value == "1" )
 174                 return true;
 175         else
 176                 return false;
 177 }
 178
 179 string
 180 ToLower ( string filename )
 181 {
 182         for ( size_t i = 1; i < filename.length (); i++ )
 183                 filename[i] = tolower ( filename[i] );
 184         return filename;
 185 }
 186
 187 IfableData::IfableData( )
 188         : asmFiles ( 0 )
 189 {
 190 }
 191
 192 void IfableData::ExtractModules( std::map<std::string, Module*> &modules )
 193 {
 194         size_t i;
 195         for ( i = 0; i < this->modules.size (); i++ )
 196                 modules.insert(std::make_pair(this->modules[i]->name, this->modules[i]));
 197 }
 198
 199 IfableData::~IfableData()
 200 {
 201         size_t i;
 202         for ( i = 0; i < includes.size (); i++ )
 203                 delete includes[i];
 204         for ( i = 0; i < defines.size (); i++ )
 205                 delete defines[i];
 206         for ( i = 0; i < libraries.size (); i++ )
 207                 delete libraries[i];
 208         for ( std::map<std::string, Property*>::const_iterator p = properties.begin(); p != properties.end(); ++ p )
 209                 delete p->second;
 210         for ( i = 0; i < compilerFlags.size (); i++ )
 211                 delete compilerFlags[i];
 212         for ( i = 0; i < modules.size(); i++ )
 213                 delete modules[i];
 214         for ( i = 0; i < compilationUnits.size (); i++ )
 215                 delete compilationUnits[i];
 216 }
 217
 218 void IfableData::ProcessXML ()
 219 {
 220         size_t i;
 221         for ( i = 0; i < includes.size (); i++ )
 222                 includes[i]->ProcessXML ();
 223         for ( i = 0; i < defines.size (); i++ )
 224                 defines[i]->ProcessXML ();
 225         for ( i = 0; i < libraries.size (); i++ )
 226                 libraries[i]->ProcessXML ();
 227         for ( std::map<std::string, Property*>::const_iterator p = properties.begin(); p != properties.end(); ++ p )
 228                 p->second->ProcessXML ();
 229         for ( i = 0; i < compilerFlags.size(); i++ )
 230                 compilerFlags[i]->ProcessXML ();
 231         for ( i = 0; i < compilationUnits.size (); i++ )
 232                 compilationUnits[i]->ProcessXML ();
 233 }
 234
 235 bool Module::GetBooleanAttribute ( const XMLElement& moduleNode, const char * name, bool default_value )
 236 {
 237         const XMLAttribute* att = moduleNode.GetAttribute ( name, false );
 238         if ( att != NULL )
 239         {
 240                 const char* p = att->value.c_str();
 241                 if ( !stricmp ( p, "true" ) || !stricmp ( p, "yes" ) )
 242                         return true;
 243                 else if ( !stricmp ( p, "false" ) || !stricmp ( p, "no" ) )
 244                         return false;
 245                 else
 246                 {
 247                         throw InvalidAttributeValueException (
 248                                 moduleNode.location,
 249                                 name,
 250                                 att->value );
 251                 }
 252         }
 253         else
 254                 return default_value;
 255 }
 256
 257 Module::Module ( const Project& project,
 258                  const XMLElement& moduleNode,
 259                  const string& modulePath )
 260         : project (project),
 261           node (moduleNode),
 262           importLibrary (NULL),
 263           delayImportLibrary (NULL),
 264           metadata (NULL),
 265           bootSector (NULL),
 266           bootstrap (NULL),
 267           autoRegister(NULL),
 268           linkerScript (NULL),
 269           pch (NULL),
 270           cplusplus (false),
 271           output (NULL),
 272           install (NULL)
 273 {
 274         if ( node.name != "module" )
 275                 throw InvalidOperationException ( __FILE__,
 276                                                   __LINE__,
 277                                                   "Module created with non-<module> node" );
 278
 279         xmlbuildFile = FixSeparator ( Path::RelativeFromWorkingDirectory ( moduleNode.xmlFile->filename () ) );
 280
 281         const XMLAttribute* att = moduleNode.GetAttribute ( "name", true );
 282         assert(att);
 283         name = att->value;
 284
 285         enabled = true;
 286
 287         att = moduleNode.GetAttribute ( "if", false );
 288         if ( att != NULL )
 289                 enabled = GetBooleanValue ( project.ResolveProperties ( att->value ) );
 290
 291         att = moduleNode.GetAttribute ( "ifnot", false );
 292         if ( att != NULL )
 293                 enabled = !GetBooleanValue ( project.ResolveProperties ( att->value ) );
 294
 295         if ( !enabled && project.configuration.Verbose )
 296                 printf("Module '%s' has been disabled.\n", name.c_str () );
 297
 298         att = moduleNode.GetAttribute ( "type", true );
 299         assert(att);
 300         type = GetModuleType ( node.location, *att );
 301
 302         att = moduleNode.GetAttribute ( "extension", false );
 303         if ( att != NULL )
 304                 extension = att->value;
 305         else
 306                 extension = GetDefaultModuleExtension ();
 307
 308         isUnicode = GetBooleanAttribute ( moduleNode, "unicode" );
 309
 310         if (isUnicode)
 311         {
 312                 // Always define UNICODE and _UNICODE
 313                 Define* pDefine = new Define ( project, this, "UNICODE" );
 314                 non_if_data.defines.push_back ( pDefine );
 315
 316                 pDefine = new Define ( project, this, "_UNICODE" );
 317                 non_if_data.defines.push_back ( pDefine );
 318         }
 319
 320         att = moduleNode.GetAttribute ( "entrypoint", false );
 321         if ( att != NULL )
 322         {
 323                 if ( att->value == "" )
 324                 {
 325                         throw InvalidAttributeValueException (
 326                                 moduleNode.location,
 327                                 "entrypoint",
 328                                 att->value );
 329                 }
 330
 331                 entrypoint = att->value;
 332                 isDefaultEntryPoint = false;
 333         }
 334         else
 335         {
 336                 entrypoint = GetDefaultModuleEntrypoint ();
 337                 isDefaultEntryPoint = true;
 338         }
 339
 340         att = moduleNode.GetAttribute ( "baseaddress", false );
 341         if ( att != NULL )
 342                 baseaddress = att->value;
 343         else
 344                 baseaddress = GetDefaultModuleBaseaddress ();
 345
 346         mangledSymbols = GetBooleanAttribute ( moduleNode, "mangledsymbols" );
 347
 348         att = moduleNode.GetAttribute ( "underscoresymbols", false );
 349         if ( att != NULL )
 350                 underscoreSymbols = att->value == "true";
 351         else
 352                 underscoreSymbols = false;
 353
 354         isStartupLib = GetBooleanAttribute ( moduleNode, "isstartuplib" );
 355         isCRT = GetBooleanAttribute ( moduleNode, "iscrt", GetDefaultModuleIsCRT () );
 356
 357         att = moduleNode.GetAttribute ( "crt", false );
 358         if ( att != NULL)
 359         {
 360                 CRT = att->value;
 361
 362                 if ( stricmp ( CRT.c_str (), "auto" ) == 0 )
 363                         CRT = GetDefaultModuleCRT ();
 364         }
 365         else
 366                 CRT = GetDefaultModuleCRT ();
 367
 368         const char * crtAttr = CRT.c_str ();
 369         if ( crtAttr == NULL || stricmp ( crtAttr, "none" ) == 0 )
 370                 dynamicCRT = false;
 371         else if ( stricmp ( crtAttr, "libc" ) == 0 )
 372                 dynamicCRT = false;
 373         else if ( stricmp ( crtAttr, "msvcrt" ) == 0 )
 374                 dynamicCRT = true;
 375         else if ( stricmp ( crtAttr, "libcntpr" ) == 0 )
 376                 dynamicCRT = false;
 377         else if ( stricmp ( crtAttr, "ntdll" ) == 0 )
 378                 dynamicCRT = true;
 379         else if ( stricmp ( crtAttr, "static" ) == 0 )
 380                 dynamicCRT = false;
 381         else if ( stricmp ( crtAttr, "dll" ) == 0 )
 382                 dynamicCRT = true;
 383         else
 384         {
 385                 throw InvalidAttributeValueException (
 386                         moduleNode.location,
 387                         "crt",
 388                         std::string ( crtAttr ) );
 389         }
 390
 391         if ( isCRT && dynamicCRT )
 392         {
 393                 throw XMLInvalidBuildFileException (
 394                         moduleNode.location,
 395                         "C runtime module '%s' cannot be compiled for a dynamically-linked C runtime",
 396                         name.c_str() );
 397         }
 398
 399         att = moduleNode.GetAttribute ( "prefix", false );
 400         if ( att != NULL )
 401                 prefix = att->value;
 402
 403         att = moduleNode.GetAttribute ( "installname", false );
 404         if ( att != NULL )
 405         {
 406                 const XMLAttribute* installbase = moduleNode.GetAttribute ( "installbase", false );
 407                 install = new FileLocation ( InstallDirectory,
 408                                              installbase ? installbase->value : "",
 409                                              att->value,
 410                                              &moduleNode );
 411
 412                 output = new FileLocation ( GetTargetDirectoryTree (),
 413                                             modulePath,
 414                                             att->value,
 415                                             &moduleNode );
 416         }
 417
 418         att = moduleNode.GetAttribute ( "output", false );
 419         if ( att != NULL )
 420         {
 421                 if (output != NULL)
 422                 {
 423                         printf ( "%s: WARNING: 'installname' overrides 'output' also defined for this module.\n",
 424                                 moduleNode.location.c_str() );
 425                 }
 426                 else
 427                 {
 428                         output = new FileLocation ( GetTargetDirectoryTree (),
 429                                                                                 modulePath,
 430                                                                                 att->value,
 431                                                                                 &moduleNode );
 432                 }
 433         }
 434
 435         /* If no one has set the output file for this module set it automatically */
 436         if (output == NULL)
 437         {
 438                 output = new FileLocation ( GetTargetDirectoryTree (),
 439                                                                         modulePath,
 440                                                                         name + extension,
 441                                                                         &moduleNode );
 442         }
 443
 444         att = moduleNode.GetAttribute ( "allowwarnings", false );
 445         if ( att == NULL )
 446         {
 447                 att = moduleNode.GetAttribute ( "warnings", false );
 448                 if ( att != NULL )
 449                 {
 450                         printf ( "%s: WARNING: 'warnings' attribute of <module> is deprecated, use 'allowwarnings' instead\n",
 451                                 moduleNode.location.c_str() );
 452                 }
 453         }
 454         if ( att != NULL )
 455                 allowWarnings = att->value == "true";
 456         else if ( project.allowWarningsSet )
 457                 allowWarnings = project.allowWarnings;
 458         else
 459                 allowWarnings = false;
 460
 461         att = moduleNode.GetAttribute ( "aliasof", false );
 462         if ( type == Alias && att != NULL )
 463                 aliasedModuleName = att->value;
 464         else
 465                 aliasedModuleName = "";
 466
 467         if ( type == BootProgram )
 468         {
 469                 att = moduleNode.GetAttribute ( "payload", true );
 470                 payload = att->value;
 471         }
 472
 473         if ( type == BootProgram || type == ElfExecutable )
 474         {
 475                 att = moduleNode.GetAttribute ( "buildtype", false );
 476                 if ( att != NULL )
 477                 {
 478                         buildtype = att->value;
 479                 }
 480                 else
 481                 {
 482                         buildtype = "BOOTPROG";
 483                 }
 484         }
 485
 486         att = moduleNode.GetAttribute ( "description", false );
 487         if (att != NULL )
 488         {
 489                 description = project.ResolveProperties(att->value);
 490         }
 491         else
 492                 description = "";
 493
 494         att = moduleNode.GetAttribute ( "lcid", false );
 495         if (type == KeyboardLayout && att != NULL )
 496                 lcid = att->value;
 497         else
 498                 lcid = "";
 499
 500         att = moduleNode.GetAttribute ( "layoutid", false );
 501         if (type == KeyboardLayout && att != NULL )
 502                 layoutId = att->value;
 503         else
 504                 layoutId = "";
 505
 506         att = moduleNode.GetAttribute ( "layoutnameresid", false );
 507         if (type == KeyboardLayout && att != NULL )
 508                 layoutNameResId = att->value;
 509         else
 510                 layoutNameResId = "";
 511
 512         SetImportLibrary ( NULL );
 513 }
 514
 515 Module::~Module ()
 516 {
 517         size_t i;
 518         for ( i = 0; i < invocations.size(); i++ )
 519                 delete invocations[i];
 520         for ( i = 0; i < dependencies.size(); i++ )
 521                 delete dependencies[i];
 522         for ( i = 0; i < compilerFlags.size(); i++ )
 523                 delete compilerFlags[i];
 524         for ( i = 0; i < linkerFlags.size(); i++ )
 525                 delete linkerFlags[i];
 526         for ( i = 0; i < stubbedComponents.size(); i++ )
 527                 delete stubbedComponents[i];
 528         for ( i = 0; i < cdfiles.size (); i++ )
 529                 delete cdfiles[i];
 530         if ( linkerScript )
 531                 delete linkerScript;
 532         if ( pch )
 533                 delete pch;
 534         if ( install )
 535                 delete install;
 536         if ( metadata )
 537                 delete metadata;
 538         if ( bootstrap )
 539                 delete bootstrap;
 540         if ( importLibrary )
 541                 delete importLibrary;
 542         if ( bootSector )
 543                 delete  bootSector;
 544         if ( dependency )
 545                 delete  dependency;
 546         if ( autoRegister )
 547                 delete autoRegister;
 548         if ( output )
 549                 delete output;
 550 }
 551
 552 void
 553 Module::ProcessXML()
 554 {
 555         if ( type == Alias )
 556         {
 557                 aliasedModuleName = project.ResolveProperties ( aliasedModuleName );
 558                 if ( aliasedModuleName == name )
 559                 {
 560                         throw XMLInvalidBuildFileException (
 561                                 node.location,
 562                                 "module '%s' cannot link against itself",
 563                                 name.c_str() );
 564                 }
 565                 const Module* m = project.LocateModule ( aliasedModuleName );
 566                 if ( !m && enabled )
 567                 {
 568                         throw XMLInvalidBuildFileException (
 569                                 node.location,
 570                                 "module '%s' trying to alias non-existant module '%s'",
 571                                 name.c_str(),
 572                                 aliasedModuleName.c_str() );
 573                 }
 574         }
 575
 576         size_t i;
 577         for ( i = 0; i < node.subElements.size(); i++ )
 578         {
 579                 ParseContext parseContext;
 580                 ProcessXMLSubElement ( *node.subElements[i], SourceDirectory, output->relative_path, parseContext );
 581         }
 582         for ( i = 0; i < invocations.size(); i++ )
 583                 invocations[i]->ProcessXML ();
 584         for ( i = 0; i < dependencies.size(); i++ )
 585                 dependencies[i]->ProcessXML ();
 586         for ( i = 0; i < compilerFlags.size(); i++ )
 587                 compilerFlags[i]->ProcessXML();
 588         for ( i = 0; i < linkerFlags.size(); i++ )
 589                 linkerFlags[i]->ProcessXML();
 590         for ( i = 0; i < stubbedComponents.size(); i++ )
 591                 stubbedComponents[i]->ProcessXML();
 592         non_if_data.ProcessXML();
 593         if ( linkerScript )
 594                 linkerScript->ProcessXML();
 595         if ( pch )
 596                 pch->ProcessXML();
 597         if ( autoRegister )
 598                 autoRegister->ProcessXML();
 599 }
 600
 601 void
 602 Module::ProcessXMLSubElement ( const XMLElement& e,
 603                                DirectoryLocation directory,
 604                                    const string& relative_path,
 605                                ParseContext& parseContext )
 606 {
 607         const XMLAttribute* att;
 608
 609         att = e.GetAttribute ( "compilerset", false );
 610
 611         if ( att )
 612         {
 613                 CompilerSet compilerSet;
 614
 615                 if ( att->value == "msc" )
 616                         compilerSet = MicrosoftC;
 617                 else if ( att->value == "gcc" )
 618                         compilerSet = GnuGcc;
 619                 else
 620                         throw InvalidAttributeValueException (
 621                                 e.location,
 622                                 "compilerset",
 623                                 att->value );
 624
 625                 if ( compilerSet != project.configuration.Compiler )
 626                         return;
 627         }
 628
 629         att = e.GetAttribute ( "linkerset", false );
 630
 631         if ( att )
 632         {
 633                 LinkerSet linkerSet;
 634
 635                 if ( att->value == "mslink" )
 636                         linkerSet = MicrosoftLink;
 637                 else if ( att->value == "ld" )
 638                         linkerSet = GnuLd;
 639                 else
 640                         throw InvalidAttributeValueException (
 641                                 e.location,
 642                                 "linkerset",
 643                                 att->value );
 644
 645                 if ( linkerSet != project.configuration.Linker )
 646                         return;
 647         }
 648
 649         CompilationUnit* pOldCompilationUnit = parseContext.compilationUnit;
 650         bool subs_invalid = false;
 651         string subpath ( relative_path );
 652         DirectoryLocation subdirectory = SourceDirectory;
 653         if ( e.name == "file" && e.value.size () > 0 )
 654         {
 655                 bool first = false;
 656                 const XMLAttribute* att = e.GetAttribute ( "first", false );
 657                 if ( att != NULL )
 658                 {
 659                         if ( !stricmp ( att->value.c_str(), "true" ) )
 660                                 first = true;
 661                         else if ( stricmp ( att->value.c_str(), "false" ) )
 662                         {
 663                                 throw XMLInvalidBuildFileException (
 664                                         e.location,
 665                                         "attribute 'first' of <file> element can only be 'true' or 'false'" );
 666                         }
 667                 }
 668                 string switches = "";
 669                 att = e.GetAttribute ( "switches", false );
 670                 if ( att != NULL )
 671                         switches = att->value;
 672                 if ( !cplusplus )
 673                 {
 674                         // check for c++ file
 675                         string ext = GetExtension ( e.value );
 676                         if ( !stricmp ( ext.c_str(), ".cpp" ) )
 677                                 cplusplus = true;
 678                         else if ( !stricmp ( ext.c_str(), ".cc" ) )
 679                                 cplusplus = true;
 680                         else if ( !stricmp ( ext.c_str(), ".cxx" ) )
 681                                 cplusplus = true;
 682                 }
 683                 File* pFile = new File ( directory,
 684                                          relative_path,
 685                                          e.value,
 686                                          first,
 687                                          switches,
 688                                          false );
 689                 if ( parseContext.compilationUnit )
 690                         parseContext.compilationUnit->AddFile ( pFile );
 691                 else
 692                 {
 693                         CompilationUnit* pCompilationUnit = new CompilationUnit ( pFile );
 694                         string ext = ToLower ( GetExtension ( e.value ) );
 695                         if ( ext == ".idl" )
 696                         {
 697                                 // put .idl files at the start of the module
 698                                 non_if_data.compilationUnits.insert (
 699                                         non_if_data.compilationUnits.begin(),
 700                                         pCompilationUnit );
 701                         }
 702                         else if ( ext == ".asm" || ext == ".s" )
 703                         {
 704                                 // put .asm files at the end of the module
 705                                 non_if_data.compilationUnits.push_back ( pCompilationUnit );
 706                                 non_if_data.asmFiles++;
 707                         }
 708                         else
 709                         {
 710                                 // put other files in the middle
 711                                 non_if_data.compilationUnits.insert (
 712                                         non_if_data.compilationUnits.end() - non_if_data.asmFiles,
 713                                         pCompilationUnit );
 714                         }
 715                 }
 716                 non_if_data.files.push_back ( pFile );
 717                 subs_invalid = true;
 718         }
 719         else if ( e.name == "library" && e.value.size () )
 720         {
 721                 const XMLAttribute* att = e.GetAttribute ( "delayimport", false );
 722                 Library* pLibrary = new Library ( e, *this, e.value );
 723                 if ( att && !stricmp ( att->value.c_str(), "true" ) )
 724                         pLibrary->delayimp = true;
 725                 non_if_data.libraries.push_back ( pLibrary );
 726                 subs_invalid = true;
 727         }
 728         else if ( e.name == "directory" )
 729         {
 730                 const XMLAttribute* att = e.GetAttribute ( "name", true );
 731                 const XMLAttribute* root = e.GetAttribute ( "root", false );
 732                 assert(att);
 733                 if ( root )
 734                 {
 735                         if ( root->value == "intermediate" )
 736                                 subdirectory = IntermediateDirectory;
 737                         else if ( root->value == "output" )
 738                                 subdirectory = OutputDirectory;
 739                         else
 740                         {
 741                                 throw InvalidAttributeValueException (
 742                                         e.location,
 743                                         "root",
 744                                         root->value );
 745                         }
 746                 }
 747                 subpath = GetSubPath ( this->project, e.location, relative_path, att->value );
 748         }
 749         else if ( e.name == "include" )
 750         {
 751                 Include* include = new Include ( project, &e, this );
 752                 non_if_data.includes.push_back ( include );
 753                 subs_invalid = true;
 754         }
 755         else if ( e.name == "define" || e.name == "redefine" )
 756         {
 757                 Define* pDefine = new Define ( project, this, e );
 758                 non_if_data.defines.push_back ( pDefine );
 759                 subs_invalid = true;
 760         }
 761         else if ( e.name == "metadata" )
 762         {
 763                 metadata = new Metadata ( e, *this );
 764                 subs_invalid = false;
 765         }
 766         else if ( e.name == "invoke" )
 767         {
 768                 invocations.push_back ( new Invoke ( e, *this ) );
 769                 subs_invalid = false;
 770         }
 771         else if ( e.name == "dependency" )
 772         {
 773                 dependencies.push_back ( new Dependency ( e, *this ) );
 774                 subs_invalid = true;
 775         }
 776         else if ( e.name == "bootsector" )
 777         {
 778                 bootSector = new Bootsector ( e, this );
 779                 subs_invalid = true;
 780         }
 781         else if ( e.name == "importlibrary" )
 782         {
 783                 if ( importLibrary )
 784                 {
 785                         throw XMLInvalidBuildFileException (
 786                                 e.location,
 787                                 "Only one <importlibrary> is valid per module" );
 788                 }
 789                 SetImportLibrary ( new ImportLibrary ( project, e, this, false ) );
 790                 SetDelayImportLibrary ( new ImportLibrary ( project, e, this, true ) );
 791                 subs_invalid = true;
 792         }
 793         else if ( e.name == "if" || e.name == "ifnot" )
 794         {
 795                 const XMLAttribute* name;
 796                 name = e.GetAttribute ( "property", true );
 797                 assert( name );
 798                 const Property *property = project.LookupProperty( name->value );
 799                 const string *PropertyValue;
 800                 const string EmptyString;
 801
 802                 if (property)
 803                 {
 804                         PropertyValue = &property->value;
 805                 }
 806                 else
 807                 {
 808                         // Property does not exist, treat it as being empty
 809                         PropertyValue = &EmptyString;
 810                 }
 811
 812                 const XMLAttribute* value;
 813                 value = e.GetAttribute ( "value", true );
 814                 assert( value );
 815
 816                 bool negate = ( e.name == "ifnot" );
 817                 bool equality = ( *PropertyValue == value->value );
 818                 if ( equality == negate )
 819                 {
 820                         // Failed, skip this element
 821                         if ( project.configuration.Verbose )
 822                                 printf("Skipping 'If' at %s\n", e.location.c_str () );
 823                         return;
 824                 }
 825                 subs_invalid = false;
 826         }
 827         else if ( e.name == "compilerflag" )
 828         {
 829                 CompilerFlag* pCompilerFlag = new CompilerFlag ( project, this, e );
 830                 non_if_data.compilerFlags.push_back ( pCompilerFlag );
 831                 subs_invalid = true;
 832         }
 833         else if ( e.name == "linkerflag" )
 834         {
 835                 linkerFlags.push_back ( new LinkerFlag ( project, this, e ) );
 836                 subs_invalid = true;
 837         }
 838         else if ( e.name == "linkerscript" )
 839         {
 840                 if ( linkerScript )
 841                 {
 842                         throw XMLInvalidBuildFileException (
 843                                 e.location,
 844                                 "Only one <linkerscript> is valid per module" );
 845                 }
 846                 size_t pos = e.value.find_last_of ( "/\\" );
 847                 if ( pos == string::npos )
 848                 {
 849                         linkerScript = new LinkerScript (
 850                                 e, *this, new FileLocation ( SourceDirectory, relative_path, e.value, &e ) );
 851                 }
 852                 else
 853                 {
 854                         string dir = e.value.substr ( 0, pos );
 855                         string name = e.value.substr ( pos + 1);
 856                         linkerScript = new LinkerScript (
 857                                 e, *this, new FileLocation ( SourceDirectory, relative_path + sSep + dir, name, &e ) );
 858                 }
 859                 subs_invalid = true;
 860         }
 861         else if ( e.name == "component" )
 862         {
 863                 stubbedComponents.push_back ( new StubbedComponent ( this, e ) );
 864                 subs_invalid = false;
 865         }
 866         else if ( e.name == "property" )
 867         {
 868                 throw XMLInvalidBuildFileException (
 869                         e.location,
 870                         "<property> is not a valid sub-element of <module>" );
 871         }
 872         else if ( e.name == "bootstrap" )
 873         {
 874                 bootstrap = new Bootstrap ( project, this, e );
 875                 subs_invalid = true;
 876         }
 877         else if ( e.name == "pch" )
 878         {
 879                 if ( pch )
 880                 {
 881                         throw XMLInvalidBuildFileException (
 882                                 e.location,
 883                                 "Only one <pch> is valid per module" );
 884                 }
 885                 size_t pos = e.value.find_last_of ( "/\\" );
 886                 if ( pos == string::npos )
 887                 {
 888                         pch = new PchFile (
 889                                 e, *this, new FileLocation ( SourceDirectory, relative_path, e.value, &e ) );
 890                 }
 891                 else
 892                 {
 893                         string dir = e.value.substr ( 0, pos );
 894                         string name = e.value.substr ( pos + 1);
 895                         pch = new PchFile (
 896                                 e, *this, new FileLocation ( SourceDirectory, relative_path + sSep + dir, name, &e ) );
 897                 }
 898                 subs_invalid = true;
 899         }
 900         else if ( e.name == "compilationunit" )
 901         {
 902                 if ( project.configuration.CompilationUnitsEnabled )
 903                 {
 904                         CompilationUnit* pCompilationUnit = new CompilationUnit ( &project, this, &e );
 905                         non_if_data.compilationUnits.push_back ( pCompilationUnit );
 906                         parseContext.compilationUnit = pCompilationUnit;
 907                 }
 908                 subs_invalid = false;
 909         }
 910         else if ( e.name == "autoregister" )
 911         {
 912                 if ( autoRegister != NULL)
 913                 {
 914                         throw XMLInvalidBuildFileException (
 915                                 e.location,
 916                                 "there can be only one <%s> element for a module",
 917                                 e.name.c_str() );
 918                 }
 919                 autoRegister = new AutoRegister ( project, this, e );
 920                 subs_invalid = true;
 921         }
 922         else if ( e.name == "cdfile" )
 923         {
 924                 CDFile* cdfile = new CDFile ( project, e, subpath );
 925                 cdfiles.push_back ( cdfile );
 926                 subs_invalid = true;
 927         }
 928         if ( subs_invalid && e.subElements.size() > 0 )
 929         {
 930                 throw XMLInvalidBuildFileException (
 931                         e.location,
 932                         "<%s> cannot have sub-elements",
 933                         e.name.c_str() );
 934         }
 935         for ( size_t i = 0; i < cdfiles.size (); i++ )
 936                 cdfiles[i]->ProcessXML ();
 937         for ( size_t i = 0; i < e.subElements.size (); i++ )
 938                 ProcessXMLSubElement ( *e.subElements[i], subdirectory, subpath, parseContext );
 939         parseContext.compilationUnit = pOldCompilationUnit;
 940 }
 941
 942 ModuleType
 943 Module::GetModuleType ( const string& location, const XMLAttribute& attribute )
 944 {
 945         if ( attribute.value == "buildtool" )
 946                 return BuildTool;
 947         if ( attribute.value == "staticlibrary" )
 948                 return StaticLibrary;
 949         if ( attribute.value == "hoststaticlibrary" )
 950                 return HostStaticLibrary;
 951         if ( attribute.value == "objectlibrary" )
 952                 return ObjectLibrary;
 953         if ( attribute.value == "kernel" )
 954                 return Kernel;
 955         if ( attribute.value == "kernelmodedll" )
 956                 return KernelModeDLL;
 957         if ( attribute.value == "kernelmodedriver" )
 958                 return KernelModeDriver;
 959         if ( attribute.value == "nativedll" )
 960                 return NativeDLL;
 961         if ( attribute.value == "nativecui" )
 962                 return NativeCUI;
 963         if ( attribute.value == "keyboardlayout" )
 964                 return KeyboardLayout;
 965         if ( attribute.value == "win32dll" )
 966                 return Win32DLL;
 967         if ( attribute.value == "win32ocx" )
 968                 return Win32OCX;
 969         if ( attribute.value == "win32cui" )
 970                 return Win32CUI;
 971         if ( attribute.value == "win32gui" )
 972                 return Win32GUI;
 973         if ( attribute.value == "win32scr" )
 974                 return Win32SCR;
 975         if ( attribute.value == "bootloader" )
 976                 return BootLoader;
 977         if ( attribute.value == "bootsector" )
 978                 return BootSector;
 979         if ( attribute.value == "bootprogram" )
 980                 return BootProgram;
 981         if ( attribute.value == "iso" )
 982                 return Iso;
 983         if ( attribute.value == "liveiso" )
 984                 return LiveIso;
 985         if ( attribute.value == "test" )
 986                 return Test;
 987         if ( attribute.value == "rpcserver" )
 988                 return RpcServer;
 989         if ( attribute.value == "rpcclient" )
 990                 return RpcClient;
 991         if ( attribute.value == "rpcproxy" )
 992                 return RpcProxy;
 993         if ( attribute.value == "alias" )
 994                 return Alias;
 995         if ( attribute.value == "idlheader" )
 996                 return IdlHeader;
 997         if ( attribute.value == "idlinterface" )
 998                 return IdlInterface;
 999         if ( attribute.value == "embeddedtypelib" )
1000                 return EmbeddedTypeLib;
1001         if ( attribute.value == "elfexecutable" )
1002                 return ElfExecutable;
1003         if ( attribute.value == "cabinet" )
1004                 return Cabinet;
1005         if ( attribute.value == "messageheader" )
1006                 return MessageHeader;
1007         throw InvalidAttributeValueException ( location,
1008                                                attribute.name,
1009                                                attribute.value );
1010 }
1011
1012 DirectoryLocation
1013 Module::GetTargetDirectoryTree () const
1014 {
1015         switch ( type )
1016         {
1017                 case Kernel:
1018                 case KernelModeDLL:
1019                 case KeyboardLayout:
1020                 case NativeDLL:
1021                 case Win32DLL:
1022                 case Win32OCX:
1023                 case KernelModeDriver:
1024                 case NativeCUI:
1025                 case Win32CUI:
1026                 case Test:
1027                 case Win32SCR:
1028                 case Win32GUI:
1029                 case BuildTool:
1030                 case BootLoader:
1031                 case BootSector:
1032                 case BootProgram:
1033                 case Iso:
1034                 case LiveIso:
1035                 case ElfExecutable:
1036                 case Cabinet:
1037                         return OutputDirectory;
1038                 case EmbeddedTypeLib:
1039                 case StaticLibrary:
1040                 case HostStaticLibrary:
1041                 case ObjectLibrary:
1042                 case RpcServer:
1043                 case RpcClient:
1044                 case RpcProxy:
1045                 case Alias:
1046                 case IdlHeader:
1047                 case IdlInterface:
1048                 case MessageHeader:
1049                         return IntermediateDirectory;
1050                 case TypeDontCare:
1051                         break;
1052         }
1053         throw InvalidOperationException ( __FILE__,
1054                                           __LINE__,
1055                                           "Invalid module type %d.",
1056                                           type );
1057 }
1058
1059 string
1060 Module::GetDefaultModuleExtension () const
1061 {
1062         switch (type)
1063         {
1064                 case BuildTool:
1065                         return ExePostfix;
1066                 case BootProgram:
1067                 case StaticLibrary:
1068                 case HostStaticLibrary:
1069                         return ".a";
1070                 case ObjectLibrary:
1071                         return ".o";
1072                 case Kernel:
1073                 case NativeCUI:
1074                 case Win32CUI:
1075                 case Win32GUI:
1076                         return ".exe";
1077                 case Win32SCR:
1078                         return ".scr";
1079
1080                 case KernelModeDLL:
1081                 case NativeDLL:
1082                 case KeyboardLayout:
1083                 case Win32DLL:
1084                         return ".dll";
1085                 case Win32OCX:
1086                         return ".ocx";
1087                 case KernelModeDriver:
1088                 case BootLoader:
1089                         return ".sys";
1090                 case Cabinet:
1091                         return ".cab";
1092                 case BootSector:
1093                         return ".o";
1094                 case Iso:
1095                 case LiveIso:
1096                         return ".iso";
1097                 case Test:
1098                         return ".exe";
1099                 case RpcServer:
1100                 case RpcClient:
1101                 case RpcProxy:
1102                 case IdlInterface:
1103                         return ".o";
1104                 case Alias:
1105                 case ElfExecutable:
1106                 case IdlHeader:
1107                 case MessageHeader:
1108                         return "";
1109                 case EmbeddedTypeLib:
1110                         return ".tlb";
1111                 case TypeDontCare:
1112                         break;
1113         }
1114         throw InvalidOperationException ( __FILE__,
1115                                           __LINE__ );
1116 }
1117
1118 string
1119 Module::GetDefaultModuleEntrypoint () const
1120 {
1121         switch ( type )
1122         {
1123                 case Kernel:
1124                         return "KiSystemStartup";
1125                 case KeyboardLayout:
1126                 case KernelModeDLL:
1127                 case KernelModeDriver:
1128             if (Environment::GetArch() == "arm") return "DriverEntry";
1129                         return "DriverEntry@8";
1130                 case NativeDLL:
1131             if (Environment::GetArch() == "arm") return "DllMainCRTStartup";
1132             return "DllMainCRTStartup@12";
1133                 case NativeCUI:
1134             if (Environment::GetArch() == "arm") return "NtProcessStartup";
1135             return "NtProcessStartup@4";
1136                 case Win32DLL:
1137                 case Win32OCX:
1138             if (Environment::GetArch() == "arm") return "DllMain";
1139                         return "DllMain@12";
1140                 case Win32CUI:
1141                 case Test:
1142                         return "mainCRTStartup";
1143                 case Win32SCR:
1144                 case Win32GUI:
1145                         return "WinMainCRTStartup";
1146                 case BuildTool:
1147                 case StaticLibrary:
1148                 case HostStaticLibrary:
1149                 case ObjectLibrary:
1150                 case BootLoader:
1151                 case BootSector:
1152                 case Iso:
1153                 case LiveIso:
1154                 case RpcServer:
1155                 case RpcClient:
1156                 case RpcProxy:
1157                 case Alias:
1158                 case BootProgram:
1159                 case IdlHeader:
1160                 case IdlInterface:
1161                 case MessageHeader:
1162                 case ElfExecutable:
1163                 case EmbeddedTypeLib:
1164                 case Cabinet:
1165                         return "";
1166                 case TypeDontCare:
1167                         break;
1168         }
1169         throw InvalidOperationException ( __FILE__,
1170                                           __LINE__ );
1171 }
1172
1173 string
1174 Module::GetDefaultModuleBaseaddress () const
1175 {
1176         switch ( type )
1177         {
1178                 case Kernel:
1179                         return "0x80800000";
1180                 case Win32DLL:
1181                 case Win32OCX:
1182                         return "0x10000000";
1183                 case NativeDLL:
1184                 case NativeCUI:
1185                 case Win32CUI:
1186                 case Test:
1187                         return "0x00400000";
1188                 case Win32SCR:
1189                 case Win32GUI:
1190                         return "0x00400000";
1191                 case KeyboardLayout:
1192                 case KernelModeDLL:
1193                 case KernelModeDriver:
1194                         return "0x00010000";
1195                 case ElfExecutable:
1196                         return "0xe00000";
1197                 case BuildTool:
1198                 case StaticLibrary:
1199                 case HostStaticLibrary:
1200                 case ObjectLibrary:
1201                 case BootLoader:
1202                 case BootSector:
1203                 case Iso:
1204                 case LiveIso:
1205                 case RpcServer:
1206                 case RpcClient:
1207                 case RpcProxy:
1208                 case Alias:
1209                 case BootProgram:
1210                 case IdlHeader:
1211                 case IdlInterface:
1212                 case MessageHeader:
1213                 case EmbeddedTypeLib:
1214                 case Cabinet:
1215                         return "";
1216                 case TypeDontCare:
1217                         break;
1218         }
1219         throw InvalidOperationException ( __FILE__,
1220                                           __LINE__ );
1221 }
1222
1223 std::string
1224 Module::GetDefaultModuleCRT () const
1225 {
1226         if ( isCRT )
1227                 return "static";
1228
1229         switch ( type )
1230         {
1231                 case Kernel:
1232                         return "static";
1233                 case Win32DLL:
1234                 case Win32OCX:
1235                         return "ntdll";
1236                 case NativeDLL:
1237                 case NativeCUI:
1238                         return "ntdll";
1239                 case Win32CUI:
1240                 case Win32SCR:
1241                 case Win32GUI:
1242                         return "msvcrt";
1243                 case Test:
1244                         return "msvcrt"; // BUGBUG: not sure about this
1245                 case KeyboardLayout:
1246                         return "none";
1247                 case KernelModeDLL:
1248                 case KernelModeDriver:
1249                         return "dll";
1250                 case BootLoader:
1251                         return "libcntpr";
1252                 case ElfExecutable:
1253                 case BuildTool:
1254                 case StaticLibrary:
1255                 case HostStaticLibrary:
1256                 case ObjectLibrary:
1257                 case BootSector:
1258                 case Iso:
1259                 case LiveIso:
1260                 case RpcServer:
1261                 case RpcClient:
1262                 case RpcProxy:
1263                 case Alias:
1264                 case BootProgram:
1265                 case IdlHeader:
1266                 case IdlInterface:
1267                 case MessageHeader:
1268                 case EmbeddedTypeLib:
1269                 case Cabinet:
1270                 case TypeDontCare:
1271                         return "none";
1272         }
1273         throw InvalidOperationException ( __FILE__,
1274                                           __LINE__ );
1275 }
1276
1277 bool
1278 Module::GetDefaultModuleIsCRT () const
1279 {
1280         return type == Kernel;
1281 }
1282
1283 bool
1284 Module::HasImportLibrary () const
1285 {
1286         return importLibrary != NULL && type != StaticLibrary && type != HostStaticLibrary;
1287 }
1288
1289 bool
1290 Module::IsDLL () const
1291 {
1292         switch ( type )
1293         {
1294                 case Kernel:
1295                 case KernelModeDLL:
1296                 case NativeDLL:
1297                 case KeyboardLayout:
1298                 case Win32DLL:
1299                 case Win32OCX:
1300                 case KernelModeDriver:
1301                         return true;
1302                 case NativeCUI:
1303                 case Win32CUI:
1304                 case Test:
1305                 case Win32SCR:
1306                 case Win32GUI:
1307                 case BuildTool:
1308                 case StaticLibrary:
1309                 case HostStaticLibrary:
1310                 case ObjectLibrary:
1311                 case BootLoader:
1312                 case BootSector:
1313                 case BootProgram:
1314                 case Iso:
1315                 case LiveIso:
1316                 case RpcServer:
1317                 case RpcClient:
1318                 case RpcProxy:
1319                 case Alias:
1320                 case IdlHeader:
1321                 case IdlInterface:
1322                 case MessageHeader:
1323                 case EmbeddedTypeLib:
1324                 case ElfExecutable:
1325                 case Cabinet:
1326                         return false;
1327                 case TypeDontCare:
1328                         break;
1329         }
1330         throw InvalidOperationException ( __FILE__,
1331                                           __LINE__ );
1332 }
1333
1334 string
1335 Module::GetPathWithPrefix ( const string& prefix ) const
1336 {
1337         return output->relative_path + cSep + prefix + output->name;
1338 }
1339
1340 string
1341 Module::GetPathToBaseDir () const
1342 {
1343         string temp_path = output->relative_path;
1344         string result = "..\\";
1345         while(temp_path.find ('\\') != string::npos)
1346         {
1347                 temp_path.erase (0, temp_path.find('\\')+1);
1348                 result += "..\\";
1349         }
1350         return result;
1351 }
1352
1353 string
1354 Module::GetInvocationTarget ( const int index ) const
1355 {
1356         return ssprintf ( "%s_invoke_%d",
1357                           name.c_str (),
1358                           index );
1359 }
1360
1361 string
1362 Module::GetEntryPoint(bool leadingUnderscore) const
1363 {
1364         string result = "";
1365         if (entrypoint == "0" || entrypoint == "0x0")
1366                 return "0";
1367         if (leadingUnderscore)
1368                 result = "_";
1369
1370         result += entrypoint;
1371
1372         if (Environment::GetArch() == "amd64")
1373         {
1374                 size_t at_index = result.find_last_of( '@' );
1375                 if ( at_index != result.npos )
1376                         return result.substr (0, at_index );
1377         }
1378
1379         return result;
1380 }
1381
1382 bool
1383 Module::HasFileWithExtension (
1384         const IfableData& data,
1385         const std::string& extension ) const
1386 {
1387         size_t i;
1388         for ( i = 0; i < data.compilationUnits.size (); i++ )
1389         {
1390                 CompilationUnit* compilationUnit = data.compilationUnits[i];
1391                 if ( compilationUnit->HasFileWithExtension ( extension ) )
1392                         return true;
1393         }
1394         return false;
1395 }
1396
1397 void
1398 Module::InvokeModule () const
1399 {
1400         for ( size_t i = 0; i < invocations.size (); i++ )
1401         {
1402                 Invoke& invoke = *invocations[i];
1403                 string command = FixSeparatorForSystemCommand(invoke.invokeModule->output->relative_path + "/" + invoke.invokeModule->output->name ) + " " + invoke.GetParameters ();
1404                 printf ( "Executing '%s'\n\n", command.c_str () );
1405                 int exitcode = system ( command.c_str () );
1406                 if ( exitcode != 0 )
1407                         throw InvocationFailedException ( command,
1408                                                           exitcode );
1409         }
1410 }
1411
1412
1413 void
1414 Module::SetImportLibrary ( ImportLibrary* importLibrary )
1415 {
1416         this->importLibrary = importLibrary;
1417         dependency = new FileLocation ( HasImportLibrary () ? IntermediateDirectory : output->directory,
1418                                         output->relative_path,
1419                                         HasImportLibrary () ? "lib" + name + ".a" : output->name );
1420 }
1421
1422 void
1423 Module::SetDelayImportLibrary ( ImportLibrary* importLibrary )
1424 {
1425         this->delayImportLibrary = importLibrary;
1426 }
1427
1428 std::string
1429 Module::GetDllName () const
1430 {
1431         if ( importLibrary && !importLibrary->dllname.empty() )
1432                 return importLibrary->dllname;
1433         else if ( output )
1434                 return output->name;
1435         else
1436                 throw new InvalidOperationException ( __FILE__, __LINE__, "Module %s has no dllname." );
1437 }
1438
1439 File::File ( DirectoryLocation directory,
1440              const string& relative_path,
1441              const string& name,
1442              bool _first,
1443              const string& _switches,
1444              bool _isPreCompiledHeader )
1445         : file ( directory, relative_path, name ),
1446           first(_first),
1447           switches(_switches),
1448           isPreCompiledHeader(_isPreCompiledHeader)
1449 {
1450 }
1451
1452
1453 void
1454 File::ProcessXML()
1455 {
1456 }
1457
1458
1459 std::string File::GetFullPath () const
1460 {
1461         string directory ( "" );
1462         switch ( file.directory )
1463         {
1464                 case SourceDirectory:
1465                         break;
1466                 case IntermediateDirectory:
1467                         directory = Environment::GetIntermediatePath () + sSep;
1468                         break;
1469                 default:
1470                         throw InvalidOperationException ( __FILE__,
1471                                                           __LINE__,
1472                                                           "Invalid directory %d.",
1473                                                           file.directory );
1474         }
1475
1476         if ( file.relative_path.length () > 0 )
1477                 directory += file.relative_path + sSep;
1478
1479
1480         return directory + file.name;
1481 }
1482
1483
1484 Library::Library ( const XMLElement& _node,
1485                    const Module& _module,
1486                    const string& _name )
1487         : node(&_node),
1488           module(_module),
1489           name(_name),
1490           importedModule(_module.project.LocateModule(_name)),
1491           delayimp(false)
1492 {
1493         if ( module.name == name )
1494         {
1495                 throw XMLInvalidBuildFileException (
1496                         node->location,
1497                         "module '%s' cannot link against itself",
1498                         name.c_str() );
1499         }
1500         if ( !importedModule )
1501         {
1502                 throw XMLInvalidBuildFileException (
1503                         node->location,
1504                         "module '%s' trying to import non-existant module '%s'",
1505                         module.name.c_str(),
1506                         name.c_str() );
1507         }
1508 }
1509
1510 Library::Library ( const Module& _module,
1511                    const string& _name )
1512         : node(NULL),
1513           module(_module),
1514           name(_name),
1515           importedModule(_module.project.LocateModule(_name)),
1516           delayimp(false)
1517 {
1518         if ( !importedModule )
1519         {
1520                 throw XMLInvalidBuildFileException (
1521                         "<internal>",
1522                         "module '%s' trying to import non-existant module '%s'",
1523                         module.name.c_str(),
1524                         name.c_str() );
1525         }
1526 }
1527
1528 void
1529 Library::ProcessXML()
1530 {
1531         if ( node && !module.project.LocateModule ( name ) )
1532         {
1533                 throw XMLInvalidBuildFileException (
1534                         node->location,
1535                         "module '%s' is trying to link against non-existant module '%s'",
1536                         module.name.c_str(),
1537                         name.c_str() );
1538         }
1539 }
1540
1541
1542 Invoke::Invoke ( const XMLElement& _node,
1543                  const Module& _module )
1544         : node (_node),
1545           module (_module)
1546 {
1547 }
1548
1549 void
1550 Invoke::ProcessXML()
1551 {
1552         const XMLAttribute* att = node.GetAttribute ( "module", false );
1553         if (att == NULL)
1554                 invokeModule = &module;
1555         else
1556         {
1557                 invokeModule = module.project.LocateModule ( att->value );
1558                 if ( invokeModule == NULL )
1559                 {
1560                         throw XMLInvalidBuildFileException (
1561                                 node.location,
1562                                 "module '%s' is trying to invoke non-existant module '%s'",
1563                                 module.name.c_str(),
1564                                 att->value.c_str() );
1565                 }
1566         }
1567
1568         for ( size_t i = 0; i < node.subElements.size (); i++ )
1569                 ProcessXMLSubElement ( *node.subElements[i] );
1570 }
1571
1572 void
1573 Invoke::ProcessXMLSubElement ( const XMLElement& e )
1574 {
1575         bool subs_invalid = false;
1576         if ( e.name == "input" )
1577         {
1578                 for ( size_t i = 0; i < e.subElements.size (); i++ )
1579                         ProcessXMLSubElementInput ( *e.subElements[i] );
1580         }
1581         else if ( e.name == "output" )
1582         {
1583                 for ( size_t i = 0; i < e.subElements.size (); i++ )
1584                         ProcessXMLSubElementOutput ( *e.subElements[i] );
1585         }
1586         if ( subs_invalid && e.subElements.size() > 0 )
1587         {
1588                 throw XMLInvalidBuildFileException (
1589                         e.location,
1590                         "<%s> cannot have sub-elements",
1591                         e.name.c_str() );
1592         }
1593 }
1594
1595 void
1596 Invoke::ProcessXMLSubElementInput ( const XMLElement& e )
1597 {
1598         bool subs_invalid = false;
1599         if ( e.name == "inputfile" && e.value.size () > 0 )
1600         {
1601                 input.push_back ( new InvokeFile (
1602                         e, FixSeparator ( module.output->relative_path + cSep + e.value ) ) );
1603                 subs_invalid = true;
1604         }
1605         if ( subs_invalid && e.subElements.size() > 0 )
1606         {
1607                 throw XMLInvalidBuildFileException (
1608                         e.location,
1609                         "<%s> cannot have sub-elements",
1610                         e.name.c_str() );
1611         }
1612 }
1613
1614 void
1615 Invoke::ProcessXMLSubElementOutput ( const XMLElement& e )
1616 {
1617         bool subs_invalid = false;
1618         if ( e.name == "outputfile" && e.value.size () > 0 )
1619         {
1620                 output.push_back ( new InvokeFile (
1621                         e, FixSeparator ( module.output->relative_path + cSep + e.value ) ) );
1622                 subs_invalid = true;
1623         }
1624         if ( subs_invalid && e.subElements.size() > 0 )
1625         {
1626                 throw XMLInvalidBuildFileException (
1627                         e.location,
1628                         "<%s> cannot have sub-elements",
1629                         e.name.c_str() );
1630         }
1631 }
1632
1633 void
1634 Invoke::GetTargets ( string_list& targets ) const
1635 {
1636         for ( size_t i = 0; i < output.size (); i++ )
1637         {
1638                 InvokeFile& file = *output[i];
1639                 targets.push_back ( NormalizeFilename ( file.name ) );
1640         }
1641 }
1642
1643 string
1644 Invoke::GetParameters () const
1645 {
1646         string parameters ( "" );
1647         size_t i;
1648         for ( i = 0; i < output.size (); i++ )
1649         {
1650                 if ( parameters.length () > 0)
1651                         parameters += " ";
1652                 InvokeFile& invokeFile = *output[i];
1653                 if ( invokeFile.switches.length () > 0 )
1654                 {
1655                         parameters += invokeFile.switches + " ";
1656                 }
1657                 parameters += invokeFile.name;
1658         }
1659
1660         for ( i = 0; i < input.size (); i++ )
1661         {
1662                 if ( parameters.length () > 0 )
1663                         parameters += " ";
1664                 InvokeFile& invokeFile = *input[i];
1665                 if ( invokeFile.switches.length () > 0 )
1666                 {
1667                         parameters += invokeFile.switches;
1668                         parameters += " ";
1669                 }
1670                 parameters += invokeFile.name ;
1671         }
1672
1673         return parameters;
1674 }
1675
1676
1677 InvokeFile::InvokeFile ( const XMLElement& _node,
1678                          const string& _name )
1679         : node (_node),
1680       name (_name)
1681 {
1682         const XMLAttribute* att = _node.GetAttribute ( "switches", false );
1683         if (att != NULL)
1684                 switches = att->value;
1685         else
1686                 switches = "";
1687 }
1688
1689 void
1690 InvokeFile::ProcessXML()
1691 {
1692 }
1693
1694
1695 Dependency::Dependency ( const XMLElement& _node,
1696                          const Module& _module )
1697         : node (_node),
1698           module (_module),
1699           dependencyModule (NULL)
1700 {
1701 }
1702
1703 void
1704 Dependency::ProcessXML()
1705 {
1706         dependencyModule = module.project.LocateModule ( node.value );
1707         if ( dependencyModule == NULL )
1708         {
1709                 throw XMLInvalidBuildFileException (
1710                         node.location,
1711                         "module '%s' depend on non-existant module '%s'",
1712                         module.name.c_str(),
1713                         node.value.c_str() );
1714         }
1715 }
1716
1717 Bootsector::Bootsector ( const XMLElement& _node,
1718                          const Module* _module )
1719         : node (_node),
1720           module (_module),
1721           bootSectorModule (NULL)
1722 {
1723         if ( !IsSupportedModuleType ( module->type ) )
1724         {
1725                 throw XMLInvalidBuildFileException (
1726                         node.location,
1727                         "<bootsector> is not applicable for this module type." );
1728         }
1729
1730         bootSectorModule = module->project.LocateModule ( node.value );
1731         if ( bootSectorModule == NULL )
1732         {
1733                 throw XMLInvalidBuildFileException (
1734                         node.location,
1735                         "module '%s' depend on non-existant module '%s'",
1736                         module->name.c_str(),
1737                         node.value.c_str() );
1738         }
1739
1740         if (bootSectorModule->type != BootSector)
1741         {
1742                 throw XMLInvalidBuildFileException (
1743                         node.location,
1744                         "module '%s' is referencing non BootSector module '%s'",
1745                         module->name.c_str(),
1746                         node.value.c_str() );
1747         }
1748 }
1749
1750 void
1751 Bootsector::ProcessXML()
1752 {
1753 }
1754
1755 bool
1756 Bootsector::IsSupportedModuleType ( ModuleType type )
1757 {
1758         if ( type == Iso ||
1759              type == LiveIso )
1760         {
1761                 return true;
1762         }
1763
1764         return false;
1765 }
1766
1767 Metadata::Metadata ( const XMLElement& _node,
1768                      const Module& _module )
1769         : node (_node),
1770           module (_module)
1771 {
1772         /* The module name */
1773         const XMLAttribute* att = _node.GetAttribute ( "name", false );
1774         if (att != NULL)
1775                 name = att->value;
1776         else
1777                 name = module.name;
1778
1779         /* The module description */
1780         att = _node.GetAttribute ( "description", false );
1781         if (att != NULL)
1782                 description = att->value;
1783         else
1784                 description = "";
1785
1786         /* The module version */
1787         att = _node.GetAttribute ( "version", false );
1788         if (att != NULL)
1789                 version = att->value;
1790         else
1791                 version = "";
1792
1793         /* The module copyright */
1794         att = _node.GetAttribute ( "copyright", false );
1795         if (att != NULL)
1796                 copyright = att->value;
1797         else
1798                 copyright = "";
1799
1800         att = _node.GetAttribute ( "url", false );
1801         if (att != NULL)
1802                 url = att->value;
1803         else
1804                 url = "";
1805
1806         /* When was this module updated */
1807         att = _node.GetAttribute ( "date", false );
1808         if (att != NULL)
1809                 date = att->value;
1810         else
1811                 date = "?";
1812
1813         /* When was this module updated */
1814         att = _node.GetAttribute ( "owner", false );
1815         if (att != NULL)
1816                 owner = att->value;
1817         else
1818                 owner = "ReactOS";
1819 }
1820
1821
1822 ImportLibrary::~ImportLibrary ()
1823 {
1824         delete source;
1825         delete target;
1826 }
1827
1828
1829 ImportLibrary::ImportLibrary ( const Project& project,
1830                                const XMLElement& node,
1831                                const Module* module,
1832                                bool delayimp )
1833         : XmlNode ( project, node ),
1834           module (module)
1835 {
1836         DirectoryLocation directory = SourceDirectory;
1837         const Module* base = module;
1838         const XMLAttribute* dllname = node.GetAttribute ( "dllname", false );
1839         const XMLAttribute* definition = node.GetAttribute ( "definition", true );
1840         assert ( definition );
1841
1842         string relative_path;
1843         const XMLAttribute* att = node.GetAttribute ( "base", false );
1844         if ( att )
1845         {
1846                         base = project.LocateModule ( att->value );
1847                         if ( !base )
1848                                 throw XMLInvalidBuildFileException (
1849                                         node.location,
1850                                         "<importlibrary> attribute 'base' references non-existant module '%s'",
1851                                         att->value.c_str() );
1852
1853         }
1854
1855         if ( base )
1856         {
1857                 relative_path = base->output->relative_path;
1858                 if ( node.value.length () > 0 && node.value != "." )
1859                         relative_path += sSep + node.value;
1860         }
1861         else
1862                 relative_path = node.value;
1863
1864         att = node.GetAttribute ( "root", false );
1865         if ( att )
1866         {
1867                 if ( att->value == "intermediate" )
1868                         directory = IntermediateDirectory;
1869                 else
1870                         throw InvalidAttributeValueException ( node.location,
1871                                                                "root",
1872                                                                att->value );
1873         }
1874
1875         if ( dllname )
1876                 this->dllname = dllname->value;
1877         else if ( module->type == StaticLibrary || module->type == HostStaticLibrary )
1878                 throw XMLInvalidBuildFileException (
1879                     node.location,
1880                     "<importlibrary> dllname attribute required." );
1881
1882         size_t index = definition->value.find_last_of ( "/\\" );
1883         if ( index == string::npos )
1884         {
1885                 source = new FileLocation ( directory,
1886                                             base->output->relative_path,
1887                                             definition->value,
1888                                             &node );
1889         }
1890         else
1891         {
1892                 string dir = definition->value.substr ( 0, index );
1893                 string name = definition->value.substr ( index + 1);
1894                 source = new FileLocation ( directory,
1895                                             NormalizeFilename ( base->output->relative_path + sSep + dir ),
1896                                             name,
1897                                             &node );
1898         }
1899
1900         target = new FileLocation ( IntermediateDirectory,
1901                                     base->output->relative_path,
1902                                     "lib" + module->name + (delayimp ? ".delayimp.a" :  ".a" ));
1903
1904 }
1905
1906
1907 Property::Property ( const XMLElement& node_,
1908                      const Project& project_,
1909                      const Module* module_ )
1910         : project(project_), module(module_)
1911 {
1912         const XMLAttribute* att;
1913
1914         att = node_.GetAttribute ( "name", true );
1915         assert(att);
1916         name = project.ResolveProperties ( att->value );
1917
1918         att = node_.GetAttribute ( "value", true );
1919         assert(att);
1920         value = att->value;
1921
1922         att = node_.GetAttribute ( "internal", false );
1923         if ( att != NULL )
1924         {
1925                 const char* p = att->value.c_str();
1926                 if ( !stricmp ( p, "true" ) || !stricmp ( p, "yes" ) )
1927                         isInternal = true;
1928                 else if ( !stricmp ( p, "false" ) || !stricmp ( p, "no" ) )
1929                         isInternal = false;
1930                 else
1931                 {
1932                         throw InvalidAttributeValueException (
1933                                 node_.location,
1934                                 "internal",
1935                                 att->value );
1936                 }
1937         }
1938         else
1939                 isInternal = false;
1940 }
1941
1942 Property::Property ( const Project& project_,
1943                      const Module* module_,
1944                      const std::string& name_,
1945                      const std::string& value_ )
1946         : project(project_), module(module_), name(name_), value(value_)
1947 {
1948 }
1949
1950 void
1951 Property::ProcessXML()
1952 {
1953 }
1954
1955
1956 PchFile::PchFile (
1957         const XMLElement& node_,
1958         const Module& module_,
1959         const FileLocation *file_ )
1960         : node(node_), module(module_), file(file_)
1961 {
1962 }
1963
1964 PchFile::~PchFile()
1965 {
1966         delete file;
1967 }
1968
1969 void
1970 PchFile::ProcessXML()
1971 {
1972 }