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