EdkCompatibilityPkg/Sample/Tools/Source/ProcessDsc/ProcessDsc.c

   1 /*++
   2
   3 Copyright (c) 2004 - 2010, Intel Corporation. All rights reserved.<BR>
   4 This program and the accompanying materials
   5 are licensed and made available under the terms and conditions of the BSD License
   6 which accompanies this distribution.  The full text of the license may be found at
   7 http://opensource.org/licenses/bsd-license.php
   8
   9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  11
  12 Module Name:
  13
  14   ProcessDsc.c
  15
  16 Abstract:
  17
  18   Main module for the ProcessDsc utility.
  19
  20 --*/
  21
  22 #include <windows.h>  // for GetShortPathName()
  23 #include <stdio.h>
  24 #include <string.h>
  25 #include <ctype.h>
  26 #include <stdarg.h>
  27 #include <direct.h>   // for _mkdir()
  28 #include <errno.h>
  29 #include <stdlib.h>   // for getenv()
  30 #include <shlwapi.h>  // for PathCanonicalize()
  31 #include "DSCFile.h"
  32 #include "MultiThread.h"
  33 #include "FWVolume.h"
  34 #include "Exceptions.h"
  35 #include "Common.h"
  36
  37 #include "EfiUtilityMsgs.h"
  38 #include "TianoBind.h"
  39
  40 #define UTILITY_NAME    "ProcessDsc"
  41 #define UTILITY_VERSION "v1.0"
  42
  43 //
  44 // Common symbol name definitions. For example, the user can reference
  45 // $(BUILD_DIR) in their DSC file and we will expand it for them (usually).
  46 // I've defined the equivalents here in case we want to change the name the
  47 // user references, in which case we just change the string value here and
  48 // our code still works.
  49 //
  50 #define BUILD_DIR                       "BUILD_DIR"
  51 #define EFI_SOURCE                      "EFI_SOURCE"
  52 #define DEST_DIR                        "DEST_DIR"
  53 #define SOURCE_DIR                      "SOURCE_DIR"
  54 #define LIB_DIR                         "LIB_DIR"
  55 #define BIN_DIR                         "BIN_DIR"
  56 #define OUT_DIR                         "OUT_DIR"
  57 #define INF_FILENAME                    "INF_FILENAME"
  58 #define SOURCE_RELATIVE_PATH            "SOURCE_RELATIVE_PATH"
  59 #define SOURCE_BASE_NAME                "SOURCE_BASE_NAME"
  60 #define SOURCE_FILE_NAME                "SOURCE_FILE_NAME"    // c:\FullPath\File.c
  61 #define PROCESSOR                       "PROCESSOR"
  62 #define FV                              "FV"
  63 #define BASE_NAME                       "BASE_NAME"
  64 #define GUID                            "GUID"
  65 #define FILE_GUID                       "FILE_GUID"
  66 #define COMPONENT_TYPE_FILE             "FILE"
  67 #define BUILD_TYPE                      "BUILD_TYPE"
  68 #define FFS_EXT                         "FFS_EXT"             // FV_EXT is deprecated -- extension of FFS file
  69 #define MAKEFILE_NAME                   "MAKEFILE_NAME"       // name of component's output makefile
  70 #define PLATFORM                        "PLATFORM"            // for more granularity
  71 #define PACKAGE_FILENAME                "PACKAGE_FILENAME"
  72 #define PACKAGE                         "PACKAGE"
  73 #define PACKAGE_TAG                     "PACKAGE_TAG"         // alternate name to PACKAGE
  74 #define SHORT_NAMES                     "SHORT_NAMES"         // for 8.3 names of symbols
  75 #define APRIORI                         "APRIORI"             // to add to apriori list
  76 #define OPTIONAL_COMPONENT              "OPTIONAL"            // define as non-zero for optional INF files
  77 #define SOURCE_SELECT                   "SOURCE_SELECT"       // say SOURCE_SELECT=smm,common to select INF sources
  78 #define NONFFS_FV                       "NONFFS_FV"           // for non-FFS FV such as working & spare block FV
  79 #define SKIP_FV_NULL                    "SKIP_FV_NULL"        // define as nonzero to not build components with FV=NULL
  80 #define SOURCE_COMPILE_TYPE             "SOURCE_COMPILE_TYPE" // to build a source using a custom build section in the DSC file
  81 #define SOURCE_FILE_EXTENSION           "SOURCE_FILE_EXTENSION"
  82 #define COMPILE_SELECT                  "COMPILE_SELECT"
  83 #define SOURCE_OVERRIDE_PATH            "SOURCE_OVERRIDE_PATH"  // get source files from here first
  84 #define MAKEFILE_OUT_SECTION_NAME       "makefile.out"
  85 #define COMMON_SECTION_NAME             "common"                // shared files or functionality
  86 #define NMAKE_SECTION_NAME              "nmake"
  87 #define SOURCES_SECTION_NAME            "sources"
  88 #define COMPONENTS_SECTION_NAME         "components"
  89 #define INCLUDE_SECTION_NAME            "includes"
  90 #define DEFINES_SECTION_NAME            "defines"
  91 #define LIBRARIES_SECTION_NAME          "libraries"
  92 #define LIBRARIES_PLATFORM_SECTION_NAME "libraries.platform"
  93 #define MAKEFILE_SECTION_NAME           "makefile"
  94 #define COMPONENT_TYPE                  "component_type"
  95 #define PLATFORM_STR                    "\\platform\\"          // to determine EFI_SOURCE
  96 #define MAKEFILE_OUT_NAME               "makefile.out"          // if not specified on command line
  97 #define MODULE_MAKEFILE_NAME            "module.mak"            // record all module makefile targets
  98 #define MODULE_NAME_FILE                "module.list"           // record all module names defined in the dsc file
  99 #define GLOBAL_LINK_LIB_NAME            "CompilerStub"          // Lib added in link option, maybe removed in the future
 100 #define MODULE_BASE_NAME_WIDTH          25                      // Width for module name output
 101
 102 //
 103 // When a symbol is defined as "NULL", it gets saved in the symbol table as a 0-length
 104 // string. Use this macro to detect if a symbol has been defined this way.
 105 //
 106 #define IS_NULL_SYMBOL_VALUE(var) ((var != NULL) && (strlen (var) == 0))
 107
 108 //
 109 // Defines for file types
 110 //
 111 #define FILETYPE_UNKNOWN  0
 112 #define FILETYPE_C        1
 113 #define FILETYPE_ASM      2
 114 #define FILETYPE_S        3
 115 #define FILETYPE_VFR      4
 116 #define FILETYPE_INC      5
 117 #define FILETYPE_H        6
 118 #define FILETYPE_I        7
 119
 120
 121 typedef struct {
 122   INT8  *Extension;         // file extension
 123   INT8  *BuiltExtension;
 124   INT8  FileFlags;
 125   int   FileType;
 126 } FILETYPE;
 127
 128 //
 129 // Define masks for the FileFlags field
 130 //
 131 #define FILE_FLAG_INCLUDE 0x01
 132 #define FILE_FLAG_SOURCE  0x02
 133
 134 //
 135 // This table describes a from-to list of files. For
 136 // example, when a ".c" is built, it results in a ".obj" file.
 137 //
 138 static const FILETYPE mFileTypes[] = {
 139   {
 140     ".c",
 141     ".obj",
 142     FILE_FLAG_SOURCE,
 143     FILETYPE_C
 144   },
 145   {
 146     ".asm",
 147     ".obj",
 148     FILE_FLAG_SOURCE,
 149     FILETYPE_ASM
 150   },
 151   {
 152     ".s",
 153     ".obj",
 154     FILE_FLAG_SOURCE,
 155     FILETYPE_S
 156   },
 157   {
 158     ".vfr",
 159     ".obj",
 160     FILE_FLAG_SOURCE,
 161     FILETYPE_VFR
 162   },  // actually *.vfr -> *.c -> *.obj
 163   {
 164     ".h",
 165     NULL,
 166     FILE_FLAG_INCLUDE,
 167     FILETYPE_H
 168   },
 169   {
 170     ".inc",
 171     NULL,
 172     FILE_FLAG_INCLUDE,
 173     FILETYPE_INC
 174   },
 175   {
 176     ".i",
 177     NULL,
 178     FILE_FLAG_INCLUDE,
 179     FILETYPE_I
 180   },
 181   {
 182     NULL,
 183     NULL,
 184     0,
 185     0
 186   }
 187 };
 188
 189 //
 190 // Structure to split up a file into its different parts.
 191 //
 192 typedef struct {
 193   INT8  Drive[3];
 194   INT8  *Path;
 195   INT8  *BaseName;
 196   INT8  *Extension;
 197   int   ExtensionCode;
 198 } FILE_NAME_PARTS;
 199
 200 //
 201 // Maximum length for any line in any file after symbol expansion
 202 //
 203 #define MAX_EXP_LINE_LEN  (MAX_LINE_LEN * 2)
 204
 205 //
 206 // Linked list to keep track of all symbols
 207 //
 208 typedef struct _SYMBOL {
 209   struct _SYMBOL  *Next;
 210   int             Type; // local or global symbol
 211   INT8            *Name;
 212   INT8            *Value;
 213 } SYMBOL;
 214
 215 //
 216 // Module globals for multi-thread build
 217 //
 218 static BUILD_ITEM  **mCurrentBuildList;          // build list currently handling
 219 static BUILD_ITEM  *mCurrentBuildItem;           // build item currently handling
 220
 221 //
 222 // Define masks for the build targets
 223 //
 224 #define BUILD_TARGET_COMPONENTS 0x01
 225 #define BUILD_TARGET_LIBRARIES  0x02
 226 #define BUILD_TARGET_FVS        0x04
 227 #define BUILD_TARGET_ALL        0xff
 228
 229
 230 //
 231 // This structure is used to save globals
 232 //
 233 struct {
 234   INT8                *DscFilename;
 235   SYMBOL              *Symbol;
 236   INT8                MakefileName[MAX_PATH]; // output makefile name
 237   INT8                XRefFileName[MAX_PATH];
 238   INT8                GuidDatabaseFileName[MAX_PATH];
 239   INT8                ModuleMakefileName[MAX_PATH];
 240   FILE                *MakefileFptr;
 241   FILE                *ModuleMakefileFptr;
 242   SYMBOL              *ModuleList;
 243   SYMBOL              *OutdirList;
 244   UINT32              Verbose;
 245   UINT32              ThreadNumber;
 246   UINT32              BuildTarget;
 247   BUILD_ITEM          *LibraryList;
 248   COMPONENTS_ITEM     *ComponentsList;
 249 } gGlobals;
 250
 251 //
 252 // This gets dumped to the head of makefile.out
 253 //
 254 static const INT8 *MakefileHeader[] = {
 255   "#/*++",
 256   "#",
 257   "#  DO NOT EDIT",
 258   "#  File auto-generated by build utility",
 259   "#",
 260   "#  Module Name:",
 261   "#",
 262   "#    makefile",
 263   "#",
 264   "#  Abstract:",
 265   "#",
 266   "#    Auto-generated makefile for building of EFI components/libraries",
 267   "#",
 268   "#--*/",
 269   "",
 270   NULL
 271 };
 272
 273 //
 274 // Function prototypes
 275 //
 276 static
 277 int
 278 ProcessOptions (
 279   int  Argc,
 280   INT8 *Argv[]
 281   );
 282
 283 static
 284 void
 285 Usage (
 286   VOID
 287   );
 288
 289 static
 290 INT8              *
 291 StripLine (
 292   INT8 *Line
 293   );
 294
 295 static
 296 STATUS
 297 ParseGuidDatabaseFile (
 298   INT8 *FileName
 299   );
 300
 301 #define DSC_SECTION_TYPE_COMPONENTS         0
 302 #define DSC_SECTION_TYPE_LIBRARIES          1
 303 #define DSC_SECTION_TYPE_PLATFORM_LIBRARIES 2
 304
 305 static
 306 int
 307 ProcessSectionComponents (
 308   DSC_FILE *DscFile,
 309   int      DscSectionType,
 310   int      Instance
 311   );
 312 static
 313 int
 314 ProcessComponentFile (
 315   DSC_FILE  *DscFile,
 316   INT8      *Line,
 317   int       DscSectionType,
 318   int       Instance
 319   );
 320 static
 321 int
 322 ProcessIncludeFiles (
 323   DSC_FILE  *ComponentFile,
 324   FILE      *MakeFptr
 325   );
 326 static
 327
 328 int
 329 ProcessIncludeFilesSingle (
 330   DSC_FILE  *ComponentFile,
 331   FILE      *MakeFptr,
 332   INT8      *SectionName
 333   );
 334
 335 //
 336 // Mode flags for processing source files
 337 //
 338 #define SOURCE_MODE_BUILD_COMMANDS  0x01
 339 #define SOURCE_MODE_SOURCE_FILES    0x02
 340
 341 static
 342 int
 343 ProcessSourceFiles (
 344   DSC_FILE  *DSCFile,
 345   DSC_FILE  *ComponentFile,
 346   FILE      *MakeFptr,
 347   UINT32    Mode
 348   );
 349
 350 static
 351 int
 352 ProcessSourceFilesSection (
 353   DSC_FILE  *DSCFile,
 354   DSC_FILE  *ComponentFile,
 355   FILE      *MakeFptr,
 356   INT8      *SectionName,
 357   UINT32    Mode
 358   );
 359
 360 static
 361 int
 362 ProcessObjects (
 363   DSC_FILE  *ComponentFile,
 364   FILE      *MakeFptr
 365   );
 366
 367 static
 368 int
 369 ProcessObjectsSingle (
 370   DSC_FILE  *ComponentFile,
 371   FILE      *MakeFptr,
 372   INT8      *SectionName
 373   );
 374
 375 static
 376 int
 377 ProcessLibs (
 378   DSC_FILE  *ComponentFile,
 379   FILE      *MakeFptr
 380   );
 381
 382 static
 383 int
 384 ProcessLibsSingle (
 385   DSC_FILE  *ComponentFile,
 386   FILE      *MakeFptr,
 387   INT8      *SectionName
 388   );
 389
 390 static
 391 int
 392 ProcessIncludesSection (
 393   DSC_FILE  *ComponentFile,
 394   FILE      *MakeFptr
 395   );
 396
 397 static
 398 int
 399 ProcessIncludesSectionSingle (
 400   DSC_FILE  *ComponentFile,
 401   FILE      *MakeFptr,
 402   INT8      *SectionName
 403   );
 404
 405 static
 406 int
 407 ProcessINFNMakeSection (
 408   DSC_FILE  *ComponentFile,
 409   FILE      *MakeFptr
 410   );
 411
 412 static
 413 int
 414 ProcessINFDefinesSection (
 415   DSC_FILE  *ComponentFile
 416   );
 417
 418 static
 419 int
 420 ProcessINFDefinesSectionSingle (
 421   DSC_FILE  *ComponentFile,
 422   INT8      *SectionName
 423   );
 424
 425 static
 426 int
 427 ProcessSectionLibraries (
 428   DSC_FILE  *DscFile,
 429   long      Offset
 430   );
 431
 432 static
 433 int
 434 ProcessDSCDefinesSection (
 435   DSC_FILE *DscFile
 436   );
 437
 438 static
 439 int
 440 SetSymbolType (
 441   INT8  *SymbolName,
 442   INT8  Type
 443   );
 444
 445 static
 446 int
 447 RemoveLocalSymbols (
 448   VOID
 449   );
 450
 451 static
 452 int
 453 RemoveFileSymbols (
 454   VOID
 455   );
 456
 457 static
 458 int
 459 RemoveSymbol (
 460   INT8   *Name,
 461   INT8   SymbolType
 462   );
 463
 464 static
 465 int
 466 SetFileExtension (
 467   INT8 *FileName,
 468   INT8 *Extension
 469   );
 470
 471 static
 472 int
 473 GetSourceFileType (
 474   INT8 *FileName
 475   );
 476
 477 static
 478 int
 479 IsIncludeFile (
 480   INT8 *FileName
 481   );
 482
 483 static
 484 int
 485 WriteCompileCommands (
 486   DSC_FILE *DscFile,
 487   FILE     *MakeFptr,
 488   INT8     *FileName,
 489   INT8     *Processor
 490   );
 491
 492 static
 493 int
 494 WriteCommonMakefile (
 495   DSC_FILE *DscFile,
 496   FILE     *MakeFptr,
 497   INT8     *Processor
 498   );
 499
 500 static
 501 int
 502 WriteComponentTypeBuildCommands (
 503   DSC_FILE *DscFile,
 504   FILE     *MakeFptr,
 505   INT8     *SectionName
 506   );
 507
 508 static
 509 void
 510 StripTrailingSpaces (
 511   INT8 *Str
 512   );
 513
 514 static
 515 void
 516 FreeFileParts (
 517   FILE_NAME_PARTS *FP
 518   );
 519
 520 static
 521 FILE_NAME_PARTS   *
 522 GetFileParts (
 523   INT8 *FileName
 524   );
 525
 526 static
 527 SYMBOL            *
 528 FreeSymbols (
 529   SYMBOL *Syms
 530   );
 531
 532 static
 533 int
 534 GetEfiSource (
 535   VOID
 536   );
 537
 538 static
 539 int
 540 CreatePackageFile (
 541   DSC_FILE          *DSCFile
 542   );
 543
 544 static
 545 INT8              *
 546 BuiltFileExtension (
 547   INT8      *SourceFileName
 548   );
 549
 550 static
 551 void
 552 SmartFree (
 553   SMART_FILE  *SmartFile
 554   );
 555
 556 static
 557 int
 558 AddModuleName (
 559   SYMBOL  **SymbolList,
 560   INT8    *ModuleName,
 561   INT8    *InfName
 562   );
 563
 564 static
 565 void
 566 ReplaceSlash (
 567   INT8    *Path
 568   );
 569
 570 /*****************************************************************************/
 571 int
 572 main (
 573   int   Argc,
 574   INT8  *Argv[]
 575   )
 576 /*++
 577
 578 Routine Description:
 579
 580   Main utility entry point.
 581
 582 Arguments:
 583
 584   Argc - Standard app entry point args.
 585   Argv - Standard app entry point args.
 586
 587 Returns:
 588
 589   0  if successful
 590   non-zero otherwise
 591
 592 --*/
 593 {
 594   int                   i;
 595   DSC_FILE              DSCFile;
 596   SECTION               *Sect;
 597   INT8                  Line[MAX_LINE_LEN];
 598   INT8                  ExpLine[MAX_LINE_LEN];
 599   INT8                  *BuildDir;
 600   INT8                  *EMsg;
 601   FILE                  *FpModule;
 602   SYMBOL                *TempSymbol;
 603   COMPONENTS_ITEM       *TempComponents;
 604
 605   SetUtilityName (UTILITY_NAME);
 606
 607   InitExceptions ();
 608
 609   DSCFileInit (&DSCFile);
 610   //
 611   // Initialize the firmware volume data
 612   //
 613   CFVConstructor ();
 614   //
 615   // Exception handling for this block of code.
 616   //
 617   TryException ();
 618   //
 619   // Process command-line options.
 620   //
 621   if (ProcessOptions (Argc, Argv)) {
 622     EMsg = CatchException ();
 623     if (EMsg != NULL) {
 624       fprintf (stderr, "%s\n", EMsg);
 625     }
 626
 627     return STATUS_ERROR;
 628   }
 629   //
 630   // Parse the GUID database file if specified
 631   //
 632   if (gGlobals.GuidDatabaseFileName[0] != 0) {
 633     ParseGuidDatabaseFile (gGlobals.GuidDatabaseFileName);
 634   }
 635   //
 636   // Set the output cross-reference file if applicable
 637   //
 638   if (gGlobals.XRefFileName[0]) {
 639     CFVSetXRefFileName (gGlobals.XRefFileName);
 640   }
 641
 642   //
 643   // Now get the EFI_SOURCE directory which we use everywhere.
 644   //
 645   if (GetEfiSource ()) {
 646     return STATUS_ERROR;
 647   }
 648
 649   //
 650   // Pre-process the DSC file to get section info.
 651   //
 652   if (DSCFileSetFile (&DSCFile, gGlobals.DscFilename) != 0) {
 653     goto ProcessingError;
 654   }
 655
 656   //
 657   // Set output makefile name for single module build
 658   //
 659   strcpy (gGlobals.ModuleMakefileName, MODULE_MAKEFILE_NAME);
 660
 661   //
 662   // Try to open all final output makefiles
 663   //
 664   if ((gGlobals.MakefileFptr = fopen (gGlobals.MakefileName, "w")) == NULL) {
 665     Error (NULL, 0, 0, gGlobals.MakefileName, "failed to open output makefile for writing");
 666     goto ProcessingError;
 667   }
 668   if ((gGlobals.ModuleMakefileFptr = fopen (gGlobals.ModuleMakefileName, "w")) == NULL) {
 669     Error (NULL, 0, 0, gGlobals.ModuleMakefileName, "failed to open output makefile for writing");
 670     goto ProcessingError;
 671   }
 672
 673   //
 674   // Write the header out to the makefiles
 675   //
 676   for (i = 0; MakefileHeader[i] != NULL; i++) {
 677     fprintf (gGlobals.MakefileFptr, "%s\n", MakefileHeader[i]);
 678     fprintf (gGlobals.ModuleMakefileFptr, "%s\n", MakefileHeader[i]);
 679   }
 680
 681   //
 682   // Init global potint = NULL
 683   //
 684   gGlobals.ModuleList = NULL;
 685   gGlobals.OutdirList = NULL;
 686
 687   //
 688   // Process the [defines] section in the DSC file to get any defines we need
 689   // elsewhere
 690   //
 691   ProcessDSCDefinesSection (&DSCFile);
 692   if (ExceptionThrown ()) {
 693     goto ProcessingError;
 694   }
 695   //
 696   // Write out the [makefile.out] section data to the output makefiles
 697   //
 698   Sect = DSCFileFindSection (&DSCFile, MAKEFILE_OUT_SECTION_NAME);
 699   if (Sect != NULL) {
 700     while (DSCFileGetLine (&DSCFile, Line, sizeof (Line)) != NULL) {
 701       ExpandSymbols (Line, ExpLine, sizeof (ExpLine), 0);
 702       //
 703       // Write the line to the output makefiles
 704       //
 705       fprintf (gGlobals.MakefileFptr, ExpLine);
 706       fprintf (gGlobals.ModuleMakefileFptr, ExpLine);
 707     }
 708   }
 709
 710   //
 711   // Add a pseudo target for GLOBAL_LINK_LIB_NAME to avoid single module build
 712   // failure when this lib is not used.
 713   //
 714   fprintf (gGlobals.ModuleMakefileFptr, "%sbuild ::\n\n", GLOBAL_LINK_LIB_NAME);
 715
 716   fprintf (gGlobals.MakefileFptr, "libraries : \n");
 717   //
 718   // Process [libraries] section in the DSC file
 719   //
 720   Sect = DSCFileFindSection (&DSCFile, LIBRARIES_SECTION_NAME);
 721   if (Sect != NULL) {
 722     mCurrentBuildList = &gGlobals.LibraryList;
 723     ProcessSectionComponents (&DSCFile, DSC_SECTION_TYPE_LIBRARIES, 0);
 724   }
 725
 726   if (ExceptionThrown ()) {
 727     goto ProcessingError;
 728   }
 729   //
 730   // Process [libraries.platform] section in the DSC file
 731   //
 732   Sect = DSCFileFindSection (&DSCFile, LIBRARIES_PLATFORM_SECTION_NAME);
 733   if (Sect != NULL) {
 734     mCurrentBuildList = &gGlobals.LibraryList;
 735     ProcessSectionComponents (&DSCFile, DSC_SECTION_TYPE_PLATFORM_LIBRARIES, 0);
 736   }
 737
 738   fprintf (gGlobals.MakefileFptr, "\n");
 739   if (ExceptionThrown ()) {
 740     goto ProcessingError;
 741   }
 742
 743   //
 744   // Process [components] section in the DSC file
 745   //
 746   Sect = DSCFileFindSection (&DSCFile, COMPONENTS_SECTION_NAME);
 747   if (Sect != NULL) {
 748     fprintf (gGlobals.MakefileFptr, "components_0 : \n");
 749     TempComponents    = AddComponentsItem (&gGlobals.ComponentsList);
 750     mCurrentBuildList = &TempComponents->BuildList;
 751     ProcessSectionComponents (&DSCFile, DSC_SECTION_TYPE_COMPONENTS, 0);
 752     fprintf (gGlobals.MakefileFptr, "\n");
 753   }
 754
 755   if (ExceptionThrown ()) {
 756     goto ProcessingError;
 757   }
 758   //
 759   // Now cycle through all [components.1], [components.2], ....[components.n].
 760   // This is necessary to support building of firmware volumes that may contain
 761   // other encapsulated firmware volumes (ala capsules).
 762   //
 763   i = 1;
 764   while (1) {
 765     RemoveSymbol (FV, SYM_GLOBAL);
 766     sprintf (Line, "%s.%d", COMPONENTS_SECTION_NAME, i);
 767     Sect = DSCFileFindSection (&DSCFile, Line);
 768     if (Sect != NULL) {
 769       fprintf (gGlobals.MakefileFptr, "components_%d : \n", i);
 770       TempComponents    = AddComponentsItem (&gGlobals.ComponentsList);
 771       mCurrentBuildList = &TempComponents->BuildList;
 772       ProcessSectionComponents (&DSCFile, DSC_SECTION_TYPE_COMPONENTS, i);
 773       fprintf (gGlobals.MakefileFptr, "\n");
 774     } else {
 775       break;
 776     }
 777
 778     if (ExceptionThrown ()) {
 779       goto ProcessingError;
 780     }
 781
 782     i++;
 783   }
 784
 785 ProcessingError:
 786   EMsg = CatchException ();
 787   if (EMsg != NULL) {
 788     fprintf (stderr, "%s\n", EMsg);
 789     fprintf (stderr, "Processing aborted\n");
 790   }
 791
 792   TryException ();
 793   //
 794   // Create the FV files if no fatal errors or errors
 795   //
 796   if (GetUtilityStatus () < STATUS_ERROR) {
 797     CFVWriteInfFiles (&DSCFile, gGlobals.MakefileFptr);
 798   }
 799
 800   //
 801   // Write all module name into MODULE_NAME_FILE file.
 802   //
 803   if ((FpModule = fopen (MODULE_NAME_FILE, "w")) != NULL) {
 804     TempSymbol = gGlobals.ModuleList;
 805     while (TempSymbol != NULL) {
 806       fprintf (FpModule, " %-*s %s \n", MODULE_BASE_NAME_WIDTH, TempSymbol->Name, TempSymbol->Value);
 807       TempSymbol = TempSymbol->Next;
 808     }
 809     fclose (FpModule);
 810     FpModule = NULL;
 811   }
 812
 813   //
 814   // Close the all the output makefiles
 815   //
 816   if (gGlobals.MakefileFptr != NULL) {
 817     fclose (gGlobals.MakefileFptr);
 818     gGlobals.MakefileFptr = NULL;
 819   }
 820
 821   if (gGlobals.ModuleMakefileFptr != NULL) {
 822     fclose (gGlobals.ModuleMakefileFptr);
 823     gGlobals.ModuleMakefileFptr = NULL;
 824   }
 825
 826   //
 827   // Start multi-thread build if ThreadNumber is specified and no error status
 828   //
 829   if ((gGlobals.ThreadNumber != 0) && (GetUtilityStatus () < STATUS_ERROR)) {
 830     BuildDir = GetSymbolValue (BUILD_DIR);
 831     if (gGlobals.BuildTarget & BUILD_TARGET_LIBRARIES) {
 832       if (StartMultiThreadBuild (&gGlobals.LibraryList, gGlobals.ThreadNumber, BuildDir) != 0) {
 833         Error (NULL, 0, 0, NULL, "Multi-thread build libraries failure");
 834         goto Cleanup;
 835       }
 836     }
 837     i = 0;
 838     TempComponents = gGlobals.ComponentsList;
 839     while (TempComponents != NULL) {
 840       if (gGlobals.BuildTarget & BUILD_TARGET_COMPONENTS) {
 841         if (StartMultiThreadBuild (&TempComponents->BuildList, gGlobals.ThreadNumber, BuildDir) != 0) {
 842           Error (NULL, 0, 0, NULL, "Multi-thread build components %d failure", i);
 843           goto Cleanup;
 844         }
 845       }
 846       if (gGlobals.BuildTarget & BUILD_TARGET_FVS) {
 847         sprintf (ExpLine, "nmake -nologo -f %s fvs_%d", gGlobals.MakefileName, i);
 848         _flushall ();
 849         if (system (ExpLine)) {
 850           Error (NULL, 0, 0, NULL, "Build FVs for components %d failure", i);
 851           goto Cleanup;
 852         }
 853       }
 854       i++;
 855       TempComponents = TempComponents->Next;
 856     }
 857   }
 858
 859 Cleanup:
 860   //
 861   // Clean up
 862   //
 863   FreeBuildList (gGlobals.LibraryList);
 864   gGlobals.LibraryList = NULL;
 865   FreeComponentsList (gGlobals.ComponentsList);
 866   gGlobals.ComponentsList = NULL;
 867   FreeSymbols (gGlobals.ModuleList);
 868   gGlobals.ModuleList = NULL;
 869   FreeSymbols (gGlobals.OutdirList);
 870   gGlobals.OutdirList = NULL;
 871   FreeSymbols (gGlobals.Symbol);
 872   gGlobals.Symbol = NULL;
 873   CFVDestructor ();
 874   DSCFileDestroy (&DSCFile);
 875
 876   EMsg = CatchException ();
 877   if (EMsg != NULL) {
 878     fprintf (stderr, "%s\n", EMsg);
 879     fprintf (stderr, "Processing aborted\n");
 880   }
 881
 882   return GetUtilityStatus ();
 883 }
 884
 885 static
 886 int
 887 ProcessSectionComponents (
 888   DSC_FILE  *DSCFile,
 889   int       DscSectionType,
 890   int       Instance
 891   )
 892 /*++
 893
 894 Routine Description:
 895
 896   Process the [components] or [libraries] section in the description file. We
 897   use this function for both since they're very similar. Here we just
 898   read each line from the section, and if it's valid, call a function to
 899   do the actual processing of the component description file.
 900
 901 Arguments:
 902
 903   DSCFile        - structure containing section info on the description file
 904   DscSectionType - type of description section
 905
 906 Returns:
 907
 908   0     if successful
 909
 910 --*/
 911 {
 912   INT8  Line[MAX_LINE_LEN];
 913   INT8  Line2[MAX_EXP_LINE_LEN];
 914   INT8  *Cptr;
 915
 916   //
 917   // Read lines while they're valid
 918   //
 919   while (DSCFileGetLine (DSCFile, Line, sizeof (Line)) != NULL) {
 920     //
 921     // Expand symbols on the line
 922     //
 923     if (ExpandSymbols (Line, Line2, sizeof (Line2), 0)) {
 924       return STATUS_ERROR;
 925     }
 926     //
 927     // Strip the line
 928     //
 929     Cptr = StripLine (Line2);
 930     if (*Cptr) {
 931       Message (2, "Processing component line: %s", Line2);
 932       if (ProcessComponentFile (DSCFile, Line2, DscSectionType, Instance) != 0) {
 933         return STATUS_ERROR;
 934       }
 935     }
 936   }
 937
 938   return 0;
 939 }
 940
 941 static
 942 int
 943 ProcessComponentFile (
 944   DSC_FILE  *DSCFile,
 945   INT8      *ArgLine,
 946   int       DscSectionType,
 947   int       Instance
 948   )
 949 /*++
 950
 951 Routine Description:
 952
 953   Given a line from the [components] or [libraries] section of the description
 954   file, process the line to extract the component's INF filename and
 955   parameters. Then open the INF file and process it to create a corresponding
 956   makefile.
 957
 958 Arguments:
 959
 960   DSCFile               The project DSC file info structure.
 961   Libs                  Indicates whether we're processing the [components]
 962                         section or the [libraries] section.
 963   ArgLine               The actual line from the DSC file. Looks something like
 964                         one of the following:
 965
 966    dxe\drivers\vm\vm.dsc PROCESSOR=IA32 DEST_DIR=$(DEST_DIR)\xxx FV=FV1,FV2
 967    $(BUILD_DIR).\FvVariable.ffs COMPONENT_TYPE=FILE
 968    .\FvVariable.ffs COMPONENT_TYPE=FILE
 969    define  VAR1=value1 VAR2=value2
 970
 971 Returns:
 972
 973   0 if successful
 974
 975 --*/
 976 {
 977   FILE      *MakeFptr;
 978   FILE      *TempFptr;
 979   INT8      *Cptr;
 980   INT8      *name;
 981   INT8      *End;
 982   INT8      *TempCptr;
 983   INT8      FileName[MAX_PATH];
 984   INT8      ComponentFilePath[MAX_PATH];
 985   INT8      InLine[MAX_LINE_LEN];
 986   INT8      Line[MAX_LINE_LEN];
 987   INT8      *Processor;
 988   INT8      SymType;
 989   int       Len;
 990   int       ComponentCreated;
 991   int       ComponentFilePathAbsolute;
 992   int       DefineLine;
 993   DSC_FILE  ComponentFile;
 994   INT8      ComponentMakefileName[MAX_PATH];
 995   BOOLEAN   IsForFv;
 996
 997   //
 998   // Now remove all local symbols
 999   //
1000   RemoveLocalSymbols ();
1001   //
1002   // Null out the file pointer in case we take an exception somewhere
1003   // and we need to close it only if we opened it.
1004   //
1005   MakeFptr                  = NULL;
1006   ComponentFilePathAbsolute = 0;
1007   ComponentCreated          = 0;
1008   //
1009   // Skip preceeding spaces on the line
1010   //
1011   while (isspace (*ArgLine) && (*ArgLine)) {
1012     ArgLine++;
1013   }
1014   //
1015   // Find the end of the component's filename and truncate the line at that
1016   // point. From here on out ArgLine is the name of the component filename.
1017   //
1018   Cptr = ArgLine;
1019   while (!isspace (*Cptr) && *Cptr) {
1020     Cptr++;
1021   }
1022
1023   End = Cptr;
1024   if (*Cptr) {
1025     End++;
1026     *Cptr = 0;
1027   }
1028   //
1029   // Exception-handle processing of this component description file
1030   //
1031   TryException ();
1032
1033   //
1034   // We also allow a component line format for defines of global symbols
1035   // instead of a component filename. In this case, the line looks like:
1036   // defines  x=abc y=yyy. Be nice and accept "define" and "defines" in a
1037   // case-insensitive manner. If it's defines, then make the symbols global.
1038   //
1039   if ((_stricmp (ArgLine, "define") == 0) || (_stricmp (ArgLine, "defines") == 0)) {
1040     SymType     = SYM_OVERWRITE | SYM_GLOBAL;
1041     DefineLine  = 1;
1042   } else {
1043     SymType     = SYM_OVERWRITE | SYM_LOCAL;
1044     DefineLine  = 0;
1045   }
1046   //
1047   // The rest of the component line from the DSC file should be defines
1048   //
1049   while (*End) {
1050     End = StripLine (End);
1051     if (*End) {
1052       //
1053       // If we're processing a "define abc=1 xyz=2" line, then set symbols
1054       // as globals per the SymType set above.
1055       //
1056       Len = AddSymbol (End, NULL, SymType);
1057       if (Len > 0) {
1058         End += Len;
1059       } else {
1060         Warning (NULL, 0, 0, ArgLine, "unrecognized option in description file");
1061         break;
1062       }
1063     }
1064   }
1065
1066   //
1067   // If DEBUG_BREAK or EFI_BREAKPOINT is defined, then do a debug breakpoint.
1068   //
1069   if ((GetSymbolValue ("DEBUG_BREAK") != NULL) || (GetSymbolValue ("EFI_BREAKPOINT") != NULL)) {
1070     EFI_BREAKPOINT ();
1071   }
1072
1073   //
1074   // If it's a define line, then we're done
1075   //
1076   if (DefineLine) {
1077     //
1078     // If there is NonFFS_FV, create the FVxxx.inf file
1079     // and include it in makefile.out. Remove the symbol
1080     // in order not to process it again next time
1081     //
1082     Cptr = GetSymbolValue (NONFFS_FV);
1083     if (Cptr != NULL) {
1084       NonFFSFVWriteInfFiles (DSCFile, Cptr);
1085       RemoveSymbol (NONFFS_FV, SYM_GLOBAL);
1086     }
1087
1088     goto ComponentDone;
1089   }
1090
1091   //
1092   // Expand symbols in the component description filename to expand the newly
1093   // added local symbols
1094   //
1095   ExpandSymbols (ArgLine, Line, sizeof (Line), EXPANDMODE_NO_UNDEFS);
1096
1097   //
1098   // If we have "c:\path\filename"
1099   //
1100   ReplaceSlash (Line);
1101   if (IsAbsolutePath (Line)) {
1102     ComponentFilePathAbsolute = 1;
1103   } else if (Line[0] == '.') {
1104     //
1105     // or if the path starts with ".", then it's build-dir relative.
1106     // Prepend $(BUILD_DIR) on the file name
1107     //
1108     sprintf (InLine, "%s\\%s", GetSymbolValue (BUILD_DIR), Line);
1109     strcpy (Line, InLine);
1110     ComponentFilePathAbsolute = 1;
1111   }
1112
1113   //
1114   // Save the path from the component name for later. It may be relative or
1115   // absolute.
1116   //
1117   strcpy (ComponentFilePath, Line);
1118   Cptr = ComponentFilePath + strlen (ComponentFilePath) - 1;
1119   while ((*Cptr != '\\') && (Cptr != ComponentFilePath)) {
1120     Cptr--;
1121   }
1122   //
1123   // Terminate the path.
1124   //
1125   *Cptr = 0;
1126
1127   //
1128   // Typically the given line is a component description filename. However we
1129   // also allow a FV filename (fvvariable.ffs COMPONENT_TYPE=FILE). If the
1130   // component type is "FILE", then add it to the FV list, create a package
1131   // file, and we're done.
1132   //
1133   Cptr = GetSymbolValue (COMPONENT_TYPE);
1134   if ((Cptr != NULL) && (strncmp (
1135                           Cptr,
1136                           COMPONENT_TYPE_FILE,
1137                           strlen (COMPONENT_TYPE_FILE)
1138                           ) == 0)) {
1139     if (ComponentFilePathAbsolute) {
1140       strcpy (InLine, Line);
1141     } else {
1142       sprintf (InLine, "%s\\%s", GetSymbolValue (EFI_SOURCE), Line);
1143     }
1144     CFVAddFVFile (
1145       InLine,
1146       Cptr,
1147       GetSymbolValue (FV),
1148       Instance,
1149       NULL,
1150       NULL,
1151       GetSymbolValue (APRIORI),
1152       NULL,
1153       NULL
1154       );
1155     goto ComponentDone;
1156   }
1157
1158   //
1159   // Better have defined processor by this point.
1160   //
1161   Processor = GetSymbolValue (PROCESSOR);
1162   if (Processor == NULL) {
1163     Error (NULL, 0, 0, NULL, "PROCESSOR not defined for component %s", Line);
1164     return STATUS_ERROR;
1165   }
1166
1167   //
1168   // The bin, out, and lib dirs are now = $(BUILD_DIR)/$(PROCESSOR). Set them.
1169   // Don't flag them as file paths (required for short 8.3 filenames) since
1170   // they're defined using the BUILD_DIR macro.
1171   //
1172   sprintf (InLine, "$(BUILD_DIR)\\%s", Processor);
1173   AddSymbol (BIN_DIR, InLine, SYM_LOCAL);
1174   AddSymbol (OUT_DIR, InLine, SYM_LOCAL);
1175   AddSymbol (LIB_DIR, InLine, SYM_LOCAL);
1176   //
1177   // See if it's been destined for an FV. It's possible to not be in an
1178   // FV if they just want to build it.
1179   //
1180   Cptr = GetSymbolValue (FV);
1181   if ((Cptr != NULL) && !IS_NULL_SYMBOL_VALUE (Cptr)) {
1182     IsForFv = TRUE;
1183   } else {
1184     IsForFv = FALSE;
1185   }
1186   //
1187   // As an optimization, if they've defined SKIP_FV_NULL as non-zero, and
1188   // the component is not destined for an FV, then skip it.
1189   // Since libraries are never intended for firmware volumes, we have to
1190   // build all of them.
1191   //
1192   if ((DscSectionType == DSC_SECTION_TYPE_COMPONENTS) && (IsForFv == FALSE)) {
1193     if ((GetSymbolValue (SKIP_FV_NULL) != NULL) && (atoi (GetSymbolValue (SKIP_FV_NULL)) != 0)) {
1194       Message (0, "%s not being built (FV=NULL)", FileName);
1195       goto ComponentDone;
1196     }
1197   }
1198   //
1199   // Prepend EFI_SOURCE to the component description file to get the
1200   // full path. Only do this if the path is not a full path already.
1201   //
1202   if (ComponentFilePathAbsolute == 0) {
1203     name = GetSymbolValue (EFI_SOURCE);
1204     sprintf (FileName, "%s\\%s", name, Line);
1205   } else {
1206     strcpy (FileName, Line);
1207   }
1208   //
1209   // Print a message, depending on verbose level.
1210   //
1211   if (DscSectionType == DSC_SECTION_TYPE_COMPONENTS) {
1212     Message (1, "Processing component         %s", FileName);
1213   } else {
1214     Message (1, "Processing library           %s", FileName);
1215   }
1216   //
1217   // Open the component's description file and get the sections. If we fail
1218   // to open it, see if they defined "OPTIONAL=1, in which case we'll just
1219   // ignore the component.
1220   //
1221   TempFptr = fopen (FileName, "r");
1222   if (TempFptr == NULL) {
1223     //
1224     // Better have defined OPTIONAL
1225     //
1226     if (GetSymbolValue (OPTIONAL_COMPONENT) != NULL) {
1227       if (atoi (GetSymbolValue (OPTIONAL_COMPONENT)) != 0) {
1228         Message (0, "Optional component '%s' not found", FileName);
1229         goto ComponentDone;
1230       }
1231     }
1232
1233     ParserError (0, FileName, "failed to open component file");
1234     return STATUS_ERROR;
1235   } else {
1236     fclose (TempFptr);
1237   }
1238
1239   DSCFileInit (&ComponentFile);
1240   ComponentCreated = 1;
1241   if (DSCFileSetFile (&ComponentFile, FileName)) {
1242     Error (NULL, 0, 0, NULL, "failed to preprocess component file '%s'", FileName);
1243     return STATUS_ERROR;
1244   }
1245   //
1246   // Add a symbol for the INF filename so users can create dependencies
1247   // in makefiles.
1248   //
1249   AddSymbol (INF_FILENAME, FileName, SYM_OVERWRITE | SYM_LOCAL | SYM_FILENAME);
1250   //
1251   // Process the [defines], [defines.$(PROCESSOR)], and [defines.$(PROCESSOR).$(PLATFORM)]
1252   // sections in the INF file
1253   //
1254   ProcessINFDefinesSection (&ComponentFile);
1255   //
1256   // Better have defined FILE_GUID if not a library
1257   //
1258   if ((GetSymbolValue (GUID) == NULL) &&
1259       (GetSymbolValue (FILE_GUID) == NULL) &&
1260       (DscSectionType == DSC_SECTION_TYPE_COMPONENTS)
1261       ) {
1262     Error (GetSymbolValue (INF_FILENAME), 1, 0, NULL, "missing FILE_GUID definition in component file");
1263     DSCFileDestroy (&ComponentFile);
1264     return STATUS_ERROR;
1265   }
1266   //
1267   // Better have defined base name
1268   //
1269   if (GetSymbolValue (BASE_NAME) == NULL) {
1270     Error (GetSymbolValue (INF_FILENAME), 1, 0, NULL, "missing BASE_NAME definition in INF file");
1271     DSCFileDestroy (&ComponentFile);
1272     return STATUS_ERROR;
1273   }
1274   //
1275   // Better have defined COMPONENT_TYPE, since it's used to find named sections.
1276   //
1277   if (GetSymbolValue (COMPONENT_TYPE) == NULL) {
1278     Error (GetSymbolValue (INF_FILENAME), 1, 0, NULL, "missing COMPONENT_TYPE definition in INF file");
1279     DSCFileDestroy (&ComponentFile);
1280     return STATUS_ERROR;
1281   }
1282
1283   //
1284   // Create the source directory path from the component file's path. If the component
1285   // file's path is absolute, we may have problems here. Try to account for it though.
1286   //
1287   if (ComponentFilePathAbsolute == 0) {
1288     sprintf (
1289       FileName,
1290       "%s\\%s",
1291       GetSymbolValue (EFI_SOURCE),
1292       ComponentFilePath
1293       );
1294   } else {
1295     strcpy (FileName, ComponentFilePath);
1296   }
1297   AddSymbol (SOURCE_DIR, FileName, SYM_OVERWRITE | SYM_LOCAL | SYM_FILEPATH);
1298
1299   //
1300   // Create the destination path.
1301   // They may have defined DEST_DIR on the component INF line, so it's already
1302   // been defined, If that's the case, then don't set it to the path of this file.
1303   //
1304   TempCptr = GetSymbolValue (DEST_DIR);
1305   if (TempCptr == NULL) {
1306     if (ComponentFilePathAbsolute == 0) {
1307       //
1308       // The destination path is $(BUILD_DIR)\$(PROCESSOR)\component_path
1309       //
1310       sprintf (
1311         FileName,
1312         "%s\\%s\\%s",
1313         GetSymbolValue (BUILD_DIR),
1314         Processor,
1315         ComponentFilePath
1316         );
1317     } else {
1318       //
1319       // The destination path is $(BUILD_DIR)\$(PROCESSOR)\$(BASE_NAME)
1320       //
1321       sprintf (
1322         FileName,
1323         "%s\\%s\\%s",
1324         GetSymbolValue (BUILD_DIR),
1325         Processor,
1326         GetSymbolValue (BASE_NAME)
1327         );
1328     }
1329     AddSymbol (DEST_DIR, FileName, SYM_OVERWRITE | SYM_LOCAL | SYM_FILEPATH);
1330   } else {
1331     ReplaceSlash (TempCptr);
1332   }
1333
1334   //
1335   // Create the output directory, then open the output component's makefile
1336   // we're going to create. Allow them to override the makefile name.
1337   //
1338   TempCptr = GetSymbolValue (MAKEFILE_NAME);
1339   if (TempCptr != NULL) {
1340     ExpandSymbols (TempCptr, ComponentMakefileName, sizeof (ComponentMakefileName), EXPANDMODE_NO_UNDEFS);
1341     TempCptr = ComponentMakefileName;
1342   } else {
1343     TempCptr = "makefile";
1344   }
1345
1346   sprintf (FileName, "%s\\%s", GetSymbolValue (DEST_DIR), TempCptr);
1347   //
1348   // Save it now with path info
1349   //
1350   AddSymbol (MAKEFILE_NAME, FileName, SYM_OVERWRITE | SYM_LOCAL | SYM_FILENAME);
1351
1352   if (MakeFilePath (FileName)) {
1353     return STATUS_ERROR;
1354   }
1355
1356   if ((MakeFptr = fopen (FileName, "w")) == NULL) {
1357     Error (NULL, 0, 0, FileName, "could not create makefile");
1358     return STATUS_ERROR;
1359   }
1360   //
1361   // At this point we should have all the info we need to create a package
1362   // file if setup to do so. Libraries don't use package files, so
1363   // don't do this for libs.
1364   //
1365   if (DscSectionType == DSC_SECTION_TYPE_COMPONENTS) {
1366     CreatePackageFile (DSCFile);
1367   }
1368
1369   //
1370   // Add a new build item to mCurrentBuildList
1371   //
1372   mCurrentBuildItem = AddBuildItem (mCurrentBuildList, GetSymbolValue (BASE_NAME), Processor, FileName);
1373   //
1374   // ProcessDsc allows duplicate base name libraries. Make sure the duplicate
1375   // base name libraries will be built in the same order as listed in DSC file.
1376   //
1377   AddDependency (*mCurrentBuildList, mCurrentBuildItem, mCurrentBuildItem->BaseName, 1);
1378
1379   //
1380   // Add Module name to the global module list
1381   //
1382   AddModuleName (&gGlobals.ModuleList, GetSymbolValue (BASE_NAME), GetSymbolValue (INF_FILENAME));
1383   //
1384   // Write an nmake line to makefile.out
1385   //
1386   fprintf (gGlobals.MakefileFptr, "  @cd %s\n", Processor);
1387   fprintf (gGlobals.MakefileFptr, "  $(MAKE) -f %s all\n", FileName);
1388   fprintf (gGlobals.MakefileFptr, "  @cd ..\n");
1389
1390   //
1391   // Copy the common makefile section from the description file to
1392   // the component's makefile
1393   //
1394   WriteCommonMakefile (DSCFile, MakeFptr, Processor);
1395   //
1396   // Process the component's [nmake.common] and [nmake.$(PROCESSOR)] sections
1397   //
1398   ProcessINFNMakeSection (&ComponentFile, MakeFptr);
1399   //
1400   // Create the SOURCE_FILES macro that includes the names of all source
1401   // files in this component. This macro can then be used elsewhere to
1402   // process all the files making up the component. Required for scanning
1403   // files for string localization.
1404   // Also add source files to mCurrentBuildItem.
1405   //
1406   ProcessSourceFiles (DSCFile, &ComponentFile, MakeFptr, SOURCE_MODE_SOURCE_FILES);
1407   //
1408   // Create the include paths. Process [includes.common] and
1409   // [includes.$(PROCESSOR)] and [includes.$(PROCESSOR).$(PLATFORM)] sections.
1410   //
1411   ProcessIncludesSection (&ComponentFile, MakeFptr);
1412   //
1413   // Process all include source files to create a dependency list that can
1414   // be used in the makefile.
1415   //
1416   ProcessIncludeFiles (&ComponentFile, MakeFptr);
1417   //
1418   // Process the [sources.common], [sources.$(PROCESSOR)], and
1419   // [sources.$(PROCESSOR).$(PLATFORM)] files and emit their build commands
1420   //
1421   ProcessSourceFiles (DSCFile, &ComponentFile, MakeFptr, SOURCE_MODE_BUILD_COMMANDS);
1422   //
1423   // Process sources again to create an OBJECTS macro
1424   //
1425   ProcessObjects (&ComponentFile, MakeFptr);
1426
1427   //
1428   // Add Single Module target : build and clean in top level makefile
1429   //
1430   fprintf (gGlobals.ModuleMakefileFptr, "%sbuild ::", GetSymbolValue (BASE_NAME));
1431   if (DscSectionType == DSC_SECTION_TYPE_COMPONENTS) {
1432     fprintf (gGlobals.ModuleMakefileFptr, " %sbuild", GLOBAL_LINK_LIB_NAME);
1433   }
1434
1435   //
1436   // Process all the libraries to define "LIBS = x.lib y.lib..."
1437   // Be generous and append ".lib" if they forgot.
1438   // Make a macro definition: LIBS = $(LIBS) xlib.lib ylib.lib...
1439   // Add libs dependency for single module build: basenamebuild :: xlibbuild ylibbuild ...
1440   // Also add libs dependency to mCurrentBuildItem.
1441   //
1442   ProcessLibs (&ComponentFile, MakeFptr);
1443
1444   fprintf (gGlobals.ModuleMakefileFptr, "\n");
1445
1446   fprintf (gGlobals.ModuleMakefileFptr, "  @cd %s\n", Processor);
1447   fprintf (gGlobals.ModuleMakefileFptr, "  $(MAKE) -f %s all\n", FileName);
1448   fprintf (gGlobals.ModuleMakefileFptr, "  @cd ..\n\n");
1449
1450   fprintf (gGlobals.ModuleMakefileFptr, "%sclean ::\n", GetSymbolValue (BASE_NAME));
1451   fprintf (gGlobals.ModuleMakefileFptr, "  $(MAKE) -f %s clean\n\n", FileName);
1452
1453   //
1454   // Emit commands to create the component. These are simply copied from
1455   // the description file to the component's makefile. First look for
1456   // [build.$(PROCESSOR).$(BUILD_TYPE)]. If not found, then look for if
1457   // find a [build.$(PROCESSOR).$(COMPONENT_TYPE)] line.
1458   //
1459   Cptr = GetSymbolValue (BUILD_TYPE);
1460   if (Cptr != NULL) {
1461     sprintf (InLine, "build.%s.%s", Processor, Cptr);
1462     WriteComponentTypeBuildCommands (DSCFile, MakeFptr, InLine);
1463   } else {
1464     sprintf (InLine, "build.%s.%s", Processor, GetSymbolValue (COMPONENT_TYPE));
1465     WriteComponentTypeBuildCommands (DSCFile, MakeFptr, InLine);
1466   }
1467   //
1468   // Add it to the FV if not a library
1469   //
1470   if (DscSectionType == DSC_SECTION_TYPE_COMPONENTS) {
1471     //
1472     // Create the FV filename and add it to the FV.
1473     // By this point we know it's in FV.
1474     //
1475     Cptr = GetSymbolValue (FILE_GUID);
1476     if (Cptr == NULL) {
1477       Cptr = GetSymbolValue (GUID);
1478     }
1479
1480     sprintf (InLine, "%s-%s", Cptr, GetSymbolValue (BASE_NAME));
1481     //
1482     // We've deprecated FV_EXT, which should be FFS_EXT, the extension
1483     // of the FFS file generated by GenFFSFile.
1484     //
1485     TempCptr = GetSymbolValue (FFS_EXT);
1486     if (TempCptr == NULL) {
1487       TempCptr = GetSymbolValue ("FV_EXT");
1488     }
1489
1490     CFVAddFVFile (
1491       InLine,
1492       GetSymbolValue (COMPONENT_TYPE),
1493       GetSymbolValue (FV),
1494       Instance,
1495       TempCptr,
1496       Processor,
1497       GetSymbolValue (APRIORI),
1498       GetSymbolValue (BASE_NAME),
1499       Cptr
1500       );
1501   }
1502   //
1503   // Catch any failures and print the name of the component file
1504   // being processed to assist debugging.
1505   //
1506 ComponentDone:
1507
1508   Cptr = CatchException ();
1509   if (Cptr != NULL) {
1510     fprintf (stderr, "%s\n", Cptr);
1511     sprintf (InLine, "Processing of component %s failed", ArgLine);
1512     ThrowException (InLine);
1513   }
1514
1515   if (MakeFptr != NULL) {
1516     fclose (MakeFptr);
1517   }
1518
1519   if (ComponentCreated) {
1520     DSCFileDestroy (&ComponentFile);
1521   }
1522
1523   return STATUS_SUCCESS;
1524 }
1525
1526 static
1527 int
1528 CreatePackageFile (
1529   DSC_FILE          *DSCFile
1530   )
1531 {
1532   INT8       *Package;
1533   SECTION    *TempSect;
1534   INT8       Str[MAX_LINE_LEN];
1535   INT8       StrExpanded[MAX_LINE_LEN];
1536   SMART_FILE *PkgFptr;
1537   int        Status;
1538
1539   PkgFptr = NULL;
1540
1541   //
1542   // First find out if PACKAGE_FILENAME or PACKAGE is defined. PACKAGE_FILENAME
1543   // is used to specify the exact package file to use. PACKAGE is used to
1544   // specify the package section name.
1545   //
1546   Package = GetSymbolValue (PACKAGE_FILENAME);
1547   if (Package != NULL) {
1548     //
1549     // Use existing file. We're done.
1550     //
1551     return STATUS_SUCCESS;
1552   }
1553   //
1554   // See if PACKAGE or PACKAGE_TAG is defined
1555   //
1556   Package = GetSymbolValue (PACKAGE);
1557   if (Package == NULL) {
1558     Package = GetSymbolValue (PACKAGE_TAG);
1559   }
1560
1561   if (Package == NULL) {
1562     //
1563     // Not defined either. Assume they are not using the package functionality
1564     // of this utility. However define the PACKAGE_FILENAME macro to the
1565     // best-guess value.
1566     //
1567     sprintf (
1568       Str,
1569       "%s\\%s.pkg",
1570       GetSymbolValue (SOURCE_DIR),
1571       GetSymbolValue (BASE_NAME)
1572       );
1573
1574     //
1575     // Expand symbols in the package filename
1576     //
1577     ExpandSymbols (Str, StrExpanded, sizeof (StrExpanded), EXPANDMODE_NO_UNDEFS);
1578
1579     AddSymbol (PACKAGE_FILENAME, StrExpanded, SYM_LOCAL | SYM_FILENAME);
1580     return STATUS_SUCCESS;
1581   }
1582   //
1583   // Save the position in the DSC file.
1584   // Find the [package.$(COMPONENT_TYPE).$(PACKAGE)] section in the DSC file
1585   //
1586   Status = STATUS_SUCCESS;
1587   DSCFileSavePosition (DSCFile);
1588   sprintf (Str, "%s.%s.%s", PACKAGE, GetSymbolValue (COMPONENT_TYPE), Package);
1589   TempSect = DSCFileFindSection (DSCFile, Str);
1590   if (TempSect != NULL) {
1591     //
1592     // So far so good. Create the name of the package file, then open it up
1593     // for writing. File name is c:\...\oem\platform\nt32\ia32\...\BaseName.pkg.
1594     //
1595     sprintf (
1596       Str,
1597       "%s\\%s.pkg",
1598       GetSymbolValue (DEST_DIR),
1599       GetSymbolValue (BASE_NAME)
1600       );
1601
1602     //
1603     // Expand symbols in the package filename
1604     //
1605     ExpandSymbols (Str, StrExpanded, sizeof (StrExpanded), EXPANDMODE_NO_UNDEFS);
1606
1607     //
1608     // Try to open the file, then save the file name as the PACKAGE_FILENAME
1609     // symbol for use elsewhere.
1610     //
1611     if ((PkgFptr = SmartOpen (StrExpanded)) == NULL) {
1612       Error (NULL, 0, 0, Str, "could not open package file for writing");
1613       Status = STATUS_ERROR;
1614       goto Finish;
1615     }
1616
1617     AddSymbol (PACKAGE_FILENAME, StrExpanded, SYM_LOCAL | SYM_FILENAME);
1618     //
1619     // Now read lines in from the DSC file and write them back out to the
1620     // package file (with string substitution).
1621     //
1622     while (DSCFileGetLine (DSCFile, Str, sizeof (Str)) != NULL) {
1623       //
1624       // Expand symbols, then write the line out to the package file
1625       //
1626       ExpandSymbols (Str, StrExpanded, sizeof (StrExpanded), EXPANDMODE_RECURSIVE);
1627       SmartWrite (PkgFptr, StrExpanded);
1628     }
1629   } else {
1630     Warning (
1631       NULL,
1632       0,
1633       0,
1634       NULL,
1635       "cannot locate package section [%s] in DSC file for %s",
1636       Str,
1637       GetSymbolValue (INF_FILENAME)
1638       );
1639     Status = STATUS_WARNING;
1640     goto Finish;
1641   }
1642
1643   if (PkgFptr != NULL) {
1644     SmartClose (PkgFptr);
1645   }
1646
1647 Finish:
1648   //
1649   // Restore the position in the DSC file
1650   //
1651   DSCFileRestorePosition (DSCFile);
1652
1653   return STATUS_SUCCESS;
1654 }
1655
1656 static
1657 int
1658 ProcessINFDefinesSection (
1659   DSC_FILE   *ComponentFile
1660   )
1661 /*++
1662
1663 Routine Description:
1664
1665   Process the [defines.xxx] sections of the component description file. Process
1666   platform first, then processor. In this way, if a platform wants and override,
1667   that one gets parsed first, and later assignments do not overwrite the value.
1668
1669 Arguments:
1670
1671   ComponentFile     - section info on the component file being processed
1672
1673 Returns:
1674
1675
1676 --*/
1677 {
1678   INT8  *Cptr;
1679   INT8  Str[MAX_LINE_LEN];
1680
1681   //
1682   // Find a [defines.$(PROCESSOR).$(PLATFORM)] section and process it
1683   //
1684   Cptr = GetSymbolValue (PLATFORM);
1685   if (Cptr != NULL) {
1686     sprintf (
1687       Str,
1688       "%s.%s.%s",
1689       DEFINES_SECTION_NAME,
1690       GetSymbolValue (PROCESSOR),
1691       Cptr
1692       );
1693     ProcessINFDefinesSectionSingle (ComponentFile, Str);
1694   }
1695   //
1696   // Find a [defines.$(PROCESSOR)] section and process it
1697   //
1698   sprintf (Str, "%s.%s", DEFINES_SECTION_NAME, GetSymbolValue (PROCESSOR));
1699   ProcessINFDefinesSectionSingle (ComponentFile, Str);
1700
1701   //
1702   // Find a [defines] section and process it
1703   //
1704   if (ProcessINFDefinesSectionSingle (ComponentFile, DEFINES_SECTION_NAME) != STATUS_SUCCESS) {
1705     Error (NULL, 0, 0, NULL, "missing [defines] section in component file %s", GetSymbolValue (INF_FILENAME));
1706     return STATUS_ERROR;
1707   }
1708
1709   return STATUS_SUCCESS;
1710 }
1711
1712 static
1713 int
1714 ProcessINFDefinesSectionSingle (
1715   DSC_FILE  *ComponentFile,
1716   INT8      *SectionName
1717   )
1718 {
1719   INT8    *Cptr;
1720   INT8    Str[MAX_LINE_LEN];
1721   INT8    ExpandedLine[MAX_LINE_LEN];
1722   SECTION *TempSect;
1723
1724   TempSect = DSCFileFindSection (ComponentFile, SectionName);
1725   if (TempSect != NULL) {
1726     while (DSCFileGetLine (ComponentFile, Str, sizeof (Str)) != NULL) {
1727       ExpandSymbols (Str, ExpandedLine, sizeof (ExpandedLine), 0);
1728       Cptr = StripLine (ExpandedLine);
1729       //
1730       // Don't process blank lines.
1731       //
1732       if (*Cptr) {
1733         //
1734         // Add without overwriting macros specified on the component line
1735         // in the description file
1736         //
1737         AddSymbol (Cptr, NULL, SYM_LOCAL);
1738       }
1739     }
1740   } else {
1741     return STATUS_WARNING;
1742   }
1743
1744   return STATUS_SUCCESS;
1745 }
1746
1747 static
1748 int
1749 ProcessINFNMakeSection (
1750   DSC_FILE  *ComponentFile,
1751   FILE      *MakeFptr
1752   )
1753 /*++
1754
1755 Routine Description:
1756
1757   Process the [nmake.common] and [nmake.$(PROCESSOR)] sections of the component
1758   description file and write and copy them to the component's makefile.
1759
1760 Arguments:
1761
1762   ComponentFile     - section info on the component file being processed
1763   MakeFptr          - file pointer to the component' makefile we're creating
1764
1765 Returns:
1766
1767   Always STATUS_SUCCESS right now, since the sections are optional.
1768
1769 --*/
1770 {
1771   INT8    *Cptr;
1772   INT8    Str[MAX_LINE_LEN];
1773   INT8    ExpandedLine[MAX_LINE_LEN];
1774   SECTION *TempSect;
1775
1776   //
1777   // Copy the [nmake.common] and [nmake.$(PROCESSOR)] sections from the
1778   // component file directly to the output file.
1779   // The line will be stripped and don't print blank lines
1780   //
1781   sprintf (Str, "%s.%s", NMAKE_SECTION_NAME, COMMON_SECTION_NAME);
1782   TempSect = DSCFileFindSection (ComponentFile, Str);
1783   if (TempSect != NULL) {
1784     while (DSCFileGetLine (ComponentFile, Str, sizeof (Str)) != NULL) {
1785       ExpandSymbols (
1786         Str,
1787         ExpandedLine,
1788         sizeof (ExpandedLine),
1789         EXPANDMODE_NO_DESTDIR | EXPANDMODE_NO_SOURCEDIR
1790         );
1791       Cptr = StripLine (ExpandedLine);
1792       if (*Cptr) {
1793         fprintf (MakeFptr, "%s\n", Cptr);
1794       }
1795     }
1796
1797     fprintf (MakeFptr, "\n");
1798   } else {
1799     Error (GetSymbolValue (INF_FILENAME), 1, 0, Str, "section not found in component INF file");
1800   }
1801
1802   sprintf (Str, "%s.%s", NMAKE_SECTION_NAME, GetSymbolValue (PROCESSOR));
1803   TempSect = DSCFileFindSection (ComponentFile, Str);
1804   if (TempSect != NULL) {
1805     while (DSCFileGetLine (ComponentFile, Str, sizeof (Str)) != NULL) {
1806       ExpandSymbols (
1807         Str,
1808         ExpandedLine,
1809         sizeof (ExpandedLine),
1810         EXPANDMODE_NO_DESTDIR | EXPANDMODE_NO_SOURCEDIR
1811         );
1812       Cptr = StripLine (ExpandedLine);
1813       if (*Cptr) {
1814         fprintf (MakeFptr, "%s\n", Cptr);
1815       }
1816     }
1817
1818     fprintf (MakeFptr, "\n");
1819   }
1820   //
1821   // Do the same for [nmake.$(PROCESSOR).$(PLATFORM)]
1822   //
1823   Cptr = GetSymbolValue (PLATFORM);
1824   if (Cptr != NULL) {
1825     sprintf (Str, "%s.%s.%s", NMAKE_SECTION_NAME, GetSymbolValue (PROCESSOR), Cptr);
1826     TempSect = DSCFileFindSection (ComponentFile, Str);
1827     if (TempSect != NULL) {
1828       while (DSCFileGetLine (ComponentFile, Str, sizeof (Str)) != NULL) {
1829         ExpandSymbols (
1830           Str,
1831           ExpandedLine,
1832           sizeof (ExpandedLine),
1833           EXPANDMODE_NO_DESTDIR | EXPANDMODE_NO_SOURCEDIR
1834           );
1835         Cptr = StripLine (ExpandedLine);
1836         if (*Cptr) {
1837           fprintf (MakeFptr, "%s\n", Cptr);
1838         }
1839       }
1840
1841       fprintf (MakeFptr, "\n");
1842     }
1843   }
1844
1845   return STATUS_SUCCESS;
1846 }
1847
1848 static
1849 int
1850 ProcessIncludesSection (
1851   DSC_FILE  *ComponentFile,
1852   FILE      *MakeFptr
1853   )
1854 /*++
1855
1856 Routine Description:
1857
1858   Process the [includes.common], [includes.processor], and
1859   [includes.processor.platform] section of the component description file
1860   and write the appropriate macros to the component's makefile.
1861
1862   Process in reverse order to allow overrides on platform basis.
1863
1864 Arguments:
1865
1866   ComponentFile     - section info on the component file being processed
1867   MakeFptr          - file pointer to the component' makefile we're creating
1868
1869 Returns:
1870
1871   Always STATUS_SUCCESS right now, since the sections are optional.
1872
1873 --*/
1874 {
1875   INT8  *Cptr;
1876   INT8  Str[MAX_LINE_LEN];
1877   INT8  *Processor;
1878   INT8  *OverridePath;
1879
1880   //
1881   // Write a useful comment to the output makefile so the user knows where
1882   // the data came from.
1883   //
1884   fprintf (MakeFptr, "#\n# Tool-generated list of include paths that are created\n");
1885   fprintf (MakeFptr, "# from the list of include paths in the [includes.*] sections\n");
1886   fprintf (MakeFptr, "# of the component INF file.\n#\n");
1887
1888   //
1889   // We use this a lot here, so get the value only once.
1890   //
1891   Processor = GetSymbolValue (PROCESSOR);
1892   //
1893   // If they're using an override source path, then add OverridePath and
1894   // OverridePath\$(PROCESSOR) to the list of include paths.
1895   //
1896   OverridePath = GetSymbolValue (SOURCE_OVERRIDE_PATH);
1897   if (OverridePath != NULL) {
1898     ReplaceSlash (OverridePath);
1899     fprintf (MakeFptr, "!IF EXIST(%s)\n", OverridePath);
1900     fprintf (MakeFptr, "INC = $(INC) -I %s\n", OverridePath);
1901     fprintf (MakeFptr, "!IF EXIST(%s\\%s)\n", OverridePath, Processor);
1902     fprintf (MakeFptr, "INC = $(INC) -I %s\\%s\n", OverridePath, Processor);
1903     fprintf (MakeFptr, "!ENDIF\n");
1904     fprintf (MakeFptr, "!ELSE\n");
1905     fprintf (MakeFptr, "!MESSAGE Warning: include dir %s does not exist\n", OverridePath);
1906     fprintf (MakeFptr, "!ENDIF\n");
1907   }
1908   //
1909   // Try for an [includes.$(PROCESSOR).$(PLATFORM)]
1910   //
1911   Cptr = GetSymbolValue (PLATFORM);
1912   if (Cptr != NULL) {
1913     sprintf (Str, "%s.%s.%s", INCLUDE_SECTION_NAME, Processor, Cptr);
1914     ProcessIncludesSectionSingle (ComponentFile, MakeFptr, Str);
1915   }
1916   //
1917   // Now the [includes.$(PROCESSOR)] section
1918   //
1919   sprintf (Str, "%s.%s", INCLUDE_SECTION_NAME, Processor);
1920   ProcessIncludesSectionSingle (ComponentFile, MakeFptr, Str);
1921
1922   //
1923   // Now the [includes.common] section
1924   //
1925   sprintf (Str, "%s.%s", INCLUDE_SECTION_NAME, COMMON_SECTION_NAME);
1926   ProcessIncludesSectionSingle (ComponentFile, MakeFptr, Str);
1927
1928   //
1929   // Done
1930   //
1931   fprintf (MakeFptr, "\n");
1932   return STATUS_SUCCESS;
1933 }
1934 //
1935 // Process one of the [includes.xxx] sections to create a list of all
1936 // the include paths.
1937 //
1938 static
1939 int
1940 ProcessIncludesSectionSingle (
1941   DSC_FILE  *ComponentFile,
1942   FILE      *MakeFptr,
1943   INT8      *SectionName
1944   )
1945 {
1946   INT8    *Cptr;
1947   SECTION *TempSect;
1948   INT8    Str[MAX_LINE_LEN];
1949   INT8    ExpandedLine[MAX_LINE_LEN];
1950   INT8    *Processor;
1951
1952   TempSect = DSCFileFindSection (ComponentFile, SectionName);
1953   if (TempSect != NULL) {
1954     //
1955     // Add processor subdirectory on every include path
1956     //
1957     Processor = GetSymbolValue (PROCESSOR);
1958     //
1959     // Copy lines directly
1960     //
1961     while (DSCFileGetLine (ComponentFile, Str, sizeof (Str)) != NULL) {
1962       ExpandSymbols (Str, ExpandedLine, sizeof (ExpandedLine), 0);
1963       Cptr = StripLine (ExpandedLine);
1964       //
1965       // Don't process blank lines
1966       //
1967       if (*Cptr) {
1968         ReplaceSlash (Cptr);
1969         //
1970         // Strip off trailing slash
1971         //
1972         if (Cptr[strlen (Cptr) - 1] == '\\') {
1973           Cptr[strlen (Cptr) - 1] = 0;
1974         }
1975         //
1976         // Special case of ".". Replace it with source path
1977         // and the rest of the line (for .\$(PROCESSOR))
1978         //
1979         if (*Cptr == '.') {
1980           //
1981           // Handle case of just a "."
1982           //
1983           if (Cptr[1] == 0) {
1984             fprintf (MakeFptr, "INC = $(INC) -I $(SOURCE_DIR)\n");
1985             fprintf (MakeFptr, "!IF EXIST($(SOURCE_DIR)\\%s)\n", Processor);
1986             fprintf (MakeFptr, "INC = $(INC) -I $(SOURCE_DIR)\\%s\n", Processor);
1987             fprintf (MakeFptr, "!ENDIF\n");
1988           } else {
1989             //
1990             // Handle case of ".\path\path\path" or "..\path\path\path"
1991             //
1992             fprintf (MakeFptr, "!IF EXIST($(SOURCE_DIR)\\%s)\n", Cptr);
1993             fprintf (MakeFptr, "INC = $(INC) -I $(SOURCE_DIR)\\%s\n", Cptr);
1994             fprintf (MakeFptr, "!IF EXIST($(SOURCE_DIR)\\%s\\%s)\n", Cptr, Processor);
1995             fprintf (MakeFptr, "INC = $(INC) -I $(SOURCE_DIR)\\%s\\%s\n", Cptr, Processor);
1996             fprintf (MakeFptr, "!ENDIF\n");
1997             fprintf (MakeFptr, "!ELSE\n");
1998             fprintf (MakeFptr, "!MESSAGE Warning: include dir $(SOURCE_DIR)\\%s does not exist\n", Cptr);
1999             fprintf (MakeFptr, "!ENDIF\n");
2000           }
2001         } else if ((Cptr[1] != ':') && isalpha (*Cptr)) {
2002           fprintf (MakeFptr, "!IF EXIST($(EFI_SOURCE)\\%s)\n", Cptr);
2003           fprintf (MakeFptr, "INC = $(INC) -I $(EFI_SOURCE)\\%s\n", Cptr);
2004           fprintf (MakeFptr, "!IF EXIST($(EFI_SOURCE)\\%s\\%s)\n", Cptr, Processor);
2005           fprintf (MakeFptr, "INC = $(INC) -I $(EFI_SOURCE)\\%s\\%s\n", Cptr, Processor);
2006           fprintf (MakeFptr, "!ENDIF\n");
2007           fprintf (MakeFptr, "!ELSE\n");
2008           fprintf (MakeFptr, "!MESSAGE Warning: include dir $(EFI_SOURCE)\\%s does not exist\n", Cptr);
2009           fprintf (MakeFptr, "!ENDIF\n");
2010         } else {
2011           //
2012           // The line is something like: $(EFI_SOURCE)\dxe\include. Add it to
2013           // the existing $(INC) definition. Add user includes before any
2014           // other existing paths.
2015           //
2016           fprintf (MakeFptr, "!IF EXIST(%s)\n", Cptr);
2017           fprintf (MakeFptr, "INC = $(INC) -I %s\n", Cptr);
2018           fprintf (MakeFptr, "!IF EXIST(%s\\%s)\n", Cptr, Processor);
2019           fprintf (MakeFptr, "INC = $(INC) -I %s\\%s\n", Cptr, Processor);
2020           fprintf (MakeFptr, "!ENDIF\n");
2021           fprintf (MakeFptr, "!ELSE\n");
2022           fprintf (MakeFptr, "!MESSAGE Warning: include dir %s does not exist\n", Cptr);
2023           fprintf (MakeFptr, "!ENDIF\n");
2024         }
2025       }
2026     }
2027   }
2028
2029   return STATUS_SUCCESS;
2030 }
2031
2032 static
2033 int
2034 ProcessSourceFiles (
2035   DSC_FILE  *DSCFile,
2036   DSC_FILE  *ComponentFile,
2037   FILE      *MakeFptr,
2038   UINT32    Mode
2039   )
2040 /*++
2041
2042 Routine Description:
2043
2044   Process the [sources.common], [sources.$(PROCESSOR)], and
2045   [sources.$(PROCESSOR).$(PLATFORM] sections of the component
2046   description file and write the appropriate build commands out to the
2047   component's makefile. If $(SOURCE_SELECT) is defined, then it overrides
2048   the source selections. We use this functionality for SMM.
2049
2050 Arguments:
2051
2052   ComponentFile     - section info on the component file being processed
2053   MakeFptr          - file pointer to the component' makefile we're creating
2054   DSCFile           - section info on the description file we're processing
2055   Mode              - to write build commands, or just create a list
2056                       of sources.
2057
2058 Returns:
2059
2060   Always STATUS_SUCCESS right now, since the sections are optional.
2061
2062 --*/
2063 {
2064   INT8  Str[MAX_LINE_LEN];
2065   INT8  *Processor;
2066   INT8  *Platform;
2067   INT8  *SourceSelect;
2068   INT8  *CStart;
2069   INT8  *CEnd;
2070   INT8  CSave;
2071   INT8  *CopySourceSelect;
2072
2073   if (Mode & SOURCE_MODE_SOURCE_FILES) {
2074     //
2075     // Write a useful comment to the output makefile so the user knows where
2076     // the data came from.
2077     //
2078     fprintf (MakeFptr, "#\n# Tool-generated list of source files that are created\n");
2079     fprintf (MakeFptr, "# from the list of source files in the [sources.*] sections\n");
2080     fprintf (MakeFptr, "# of the component INF file.\n#\n");
2081   }
2082
2083   //
2084   // We use this a lot here, so get the value only once.
2085   //
2086   Processor = GetSymbolValue (PROCESSOR);
2087   //
2088   // See if they defined SOURCE_SELECT=xxx,yyy in which case we'll
2089   // select each [sources.xxx] and [sources.yyy] files and process
2090   // them.
2091   //
2092   SourceSelect = GetSymbolValue (SOURCE_SELECT);
2093
2094   if (SourceSelect != NULL) {
2095     //
2096     // Make a copy of the string and break it up (comma-separated) and
2097     // select each [sources.*] file from the INF.
2098     //
2099     CopySourceSelect = (INT8 *) malloc (strlen (SourceSelect) + 1);
2100     if (CopySourceSelect == NULL) {
2101       Error (NULL, 0, 0, NULL, "failed to allocate memory");
2102       return STATUS_ERROR;
2103     }
2104
2105     strcpy (CopySourceSelect, SourceSelect);
2106     CStart  = CopySourceSelect;
2107     CEnd    = CStart;
2108     while (*CStart) {
2109       CEnd = CStart + 1;
2110       while (*CEnd && *CEnd != ',') {
2111         CEnd++;
2112       }
2113
2114       CSave = *CEnd;
2115       *CEnd = 0;
2116       sprintf (Str, "%s.%s", SOURCES_SECTION_NAME, CStart);
2117       ProcessSourceFilesSection (DSCFile, ComponentFile, MakeFptr, Str, Mode);
2118       //
2119       // Restore the terminator and advance
2120       //
2121       *CEnd   = CSave;
2122       CStart  = CEnd;
2123       if (*CStart) {
2124         CStart++;
2125       }
2126     }
2127
2128     free (CopySourceSelect);
2129
2130   } else {
2131     //
2132     // Process all the [sources.common] source files to make them build
2133     //
2134     sprintf (Str, "%s.%s", SOURCES_SECTION_NAME, COMMON_SECTION_NAME);
2135     ProcessSourceFilesSection (DSCFile, ComponentFile, MakeFptr, Str, Mode);
2136     //
2137     // Now process the [sources.$(PROCESSOR)] files.
2138     //
2139     sprintf (Str, "sources.%s", Processor);
2140     ProcessSourceFilesSection (DSCFile, ComponentFile, MakeFptr, Str, Mode);
2141     //
2142     // Now process the [sources.$(PROCESSOR).$(PLATFORM)] files.
2143     //
2144     Platform = GetSymbolValue (PLATFORM);
2145     if (Platform != NULL) {
2146       sprintf (Str, "sources.%s.%s", Processor, Platform);
2147       ProcessSourceFilesSection (DSCFile, ComponentFile, MakeFptr, Str, Mode);
2148     }
2149   }
2150
2151   fprintf (MakeFptr, "\n");
2152   return STATUS_SUCCESS;
2153 }
2154
2155 /*++
2156
2157 Routine Description:
2158   Given a source file line from an INF file, parse it to see if there are
2159   any defines on it. If so, then add them to the symbol table.
2160   Also, terminate the line after the file name.
2161
2162 Arguments:
2163   SourceFileLine - a line from a [sources.?] section of the INF file. Likely
2164   something like:
2165
2166   MySourceFile.c   BUILT_NAME=$(BUILD_DIR)\MySourceFile.obj
2167
2168 Returns:
2169   Nothing.
2170
2171 --*/
2172 static
2173 void
2174 AddFileSymbols (
2175   INT8    *SourceFileLine
2176   )
2177 {
2178   int Len;
2179   //
2180   // Skip spaces
2181   //
2182   for (; *SourceFileLine && isspace (*SourceFileLine); SourceFileLine++)
2183     ;
2184   for (; *SourceFileLine && !isspace (*SourceFileLine); SourceFileLine++)
2185     ;
2186   if (*SourceFileLine) {
2187     *SourceFileLine = 0;
2188     SourceFileLine++;
2189     //
2190     // AddSymbol() will parse it for us, and return the length. Keep calling
2191     // it until it reports an error or is done.
2192     //
2193     do {
2194       Len = AddSymbol (SourceFileLine, NULL, SYM_FILE);
2195       SourceFileLine += Len;
2196     } while (Len > 0);
2197   }
2198 }
2199 //
2200 // Process a single section of source files in the component INF file
2201 //
2202 static
2203 int
2204 ProcessSourceFilesSection (
2205   DSC_FILE  *DSCFile,
2206   DSC_FILE  *ComponentFile,
2207   FILE      *MakeFptr,
2208   INT8      *SectionName,
2209   UINT32    Mode
2210   )
2211 {
2212   INT8    *Cptr;
2213   INT8    FileName[MAX_EXP_LINE_LEN];
2214   INT8    FilePath[MAX_PATH];
2215   INT8    TempFileName[MAX_PATH];
2216   SECTION *TempSect;
2217   INT8    Str[MAX_LINE_LEN];
2218   INT8    *Processor;
2219   INT8    *OverridePath;
2220   FILE    *FPtr;
2221
2222   TempSect = DSCFileFindSection (ComponentFile, SectionName);
2223   if (TempSect != NULL) {
2224     Processor = GetSymbolValue (PROCESSOR);
2225     while (DSCFileGetLine (ComponentFile, Str, sizeof (Str)) != NULL) {
2226       Cptr = StripLine (Str);
2227       //
2228       // Don't process blank lines
2229       //
2230       if (*Cptr) {
2231         //
2232         // Expand symbols in the filename, then parse the line for symbol
2233         // definitions. AddFileSymbols() will null-terminate the line
2234         // after the file name. Save a copy for override purposes, in which
2235         // case we'll need to know the file name and path (in case it's in
2236         // a subdirectory).
2237         //
2238         ExpandSymbols (Cptr, FileName, sizeof (FileName), 0);
2239         AddFileSymbols (FileName);
2240         ReplaceSlash (FileName);
2241         //
2242         // Set the SOURCE_FILE_NAME symbol. What we have now is the name of
2243         // the file, relative to the location of the INF file. So prepend
2244         // $(SOURCE_DIR) to it first.
2245         //
2246         if (IsAbsolutePath (FileName)) {
2247           strcpy (TempFileName, FileName);
2248         } else {
2249           strcpy (TempFileName, "$(SOURCE_DIR)\\");
2250           strcat (TempFileName, FileName);
2251         }
2252         AddSymbol (SOURCE_FILE_NAME, TempFileName, SYM_FILE | SYM_OVERWRITE);
2253         //
2254         // Extract path information from the source file and set internal
2255         // variable SOURCE_RELATIVE_PATH. Only do this if the path
2256         // contains a backslash.
2257         //
2258         strcpy (FilePath, FileName);
2259         for (Cptr = FilePath + strlen (FilePath) - 1; (Cptr > FilePath) && (*Cptr != '\\'); Cptr--)
2260           ;
2261         if (*Cptr == '\\') {
2262           *(Cptr + 1) = 0;
2263           AddSymbol (SOURCE_RELATIVE_PATH, FilePath, SYM_FILE);
2264         }
2265         //
2266         // Define another internal symbol for the name of the file without
2267         // the path and extension.
2268         //
2269         for (Cptr = FileName + strlen (FileName) - 1; (Cptr > FileName) && (*Cptr != '\\'); Cptr--)
2270           ;
2271         if (*Cptr == '\\') {
2272           Cptr++;
2273         }
2274
2275         strcpy (FilePath, Cptr);
2276         //
2277         // We now have a file name with no path information. Before we do anything else,
2278         // see if OVERRIDE_PATH is set, and if so, see if file $(OVERRIDE_PATH)FileName
2279         // exists. If it does, then recursive call this function to use the override file
2280         // instead of the one from the INF file.
2281         //
2282         if (IsAbsolutePath (FileName)) {
2283           OverridePath = NULL;
2284         } else {
2285           OverridePath = GetSymbolValue (SOURCE_OVERRIDE_PATH);
2286         }
2287         if (OverridePath != NULL) {
2288           ReplaceSlash (OverridePath);
2289           //
2290           // See if the file exists. If it does, reset the SOURCE_FILE_NAME symbol.
2291           //
2292           strcpy (TempFileName, OverridePath);
2293           strcat (TempFileName, "\\");
2294           strcat (TempFileName, FileName);
2295           if ((FPtr = fopen (TempFileName, "rb")) != NULL) {
2296             fclose (FPtr);
2297             AddSymbol (SOURCE_FILE_NAME, TempFileName, SYM_FILE | SYM_OVERWRITE);
2298             //
2299             // Print a message. This function is called to create build commands
2300             // for source files, and to create a macro of all source files. Therefore
2301             // do this check so we don't print the override message multiple times.
2302             //
2303             if (Mode & SOURCE_MODE_BUILD_COMMANDS) {
2304               fprintf (stdout, "Override: %s\n", TempFileName);
2305             }
2306           } else {
2307             //
2308             // Set override path to null to use as a flag below
2309             //
2310             OverridePath = NULL;
2311           }
2312         }
2313
2314         //
2315         // Start at the end and work back
2316         //
2317         for (Cptr = FilePath + strlen (FilePath) - 1; (Cptr > FilePath) && (*Cptr != '\\') && (*Cptr != '.'); Cptr--)
2318           ;
2319         if (*Cptr == '.') {
2320           *Cptr = 0;
2321           AddSymbol (SOURCE_FILE_EXTENSION, Cptr + 1, SYM_FILE);
2322         }
2323
2324         AddSymbol (SOURCE_BASE_NAME, FilePath, SYM_FILE);
2325         //
2326         // If we're just creating the SOURCE_FILES macro, then write the
2327         // file name out to the makefile.
2328         //
2329         if (Mode & SOURCE_MODE_SOURCE_FILES) {
2330           //
2331           // If we're processing an override file, then use the file name as-is
2332           //
2333           if (OverridePath != NULL) {
2334             //
2335             // SOURCE_FILES = $(SOURCE_FILES) c:\Path\ThisFile.c
2336             //
2337             fprintf (MakeFptr, "SOURCE_FILES = $(SOURCE_FILES) %s\n", TempFileName);
2338             //
2339             // Save the source absolute path
2340             //
2341             if (PathCanonicalize (FilePath, TempFileName)) {
2342               AddSourceFile (mCurrentBuildItem, FilePath);
2343             }
2344           } else if (IsAbsolutePath (FileName)) {
2345             //
2346             // For Absolute path, don't print $(SOURCE_FILE) directory.
2347             //
2348             fprintf (MakeFptr, "SOURCE_FILES = $(SOURCE_FILES) %s\n", FileName);
2349             //
2350             // Save the source absolute path
2351             //
2352             if (PathCanonicalize (FilePath, FileName)) {
2353               AddSourceFile (mCurrentBuildItem, FilePath);
2354             }
2355           } else {
2356             //
2357             // SOURCE_FILES = $(SOURCE_FILES) $(SOURCE_DIR)\ThisFile.c
2358             //
2359             fprintf (MakeFptr, "SOURCE_FILES = $(SOURCE_FILES) $(SOURCE_DIR)\\%s\n", FileName);
2360             //
2361             // Save the source absolute path
2362             //
2363             sprintf (Str, "%s\\%s", GetSymbolValue (SOURCE_DIR), FileName);
2364             if (PathCanonicalize (FilePath, Str)) {
2365               AddSourceFile (mCurrentBuildItem, FilePath);
2366             }
2367           }
2368         } else if (Mode & SOURCE_MODE_BUILD_COMMANDS) {
2369           //
2370           // Write the build commands for this file per the build commands
2371           // for this file type as defined in the description file.
2372           // Also create the directory for it in the build path.
2373           //
2374           WriteCompileCommands (DSCFile, MakeFptr, FileName, Processor);
2375           if (!IsAbsolutePath (FileName)) {
2376             sprintf (Str, "%s\\%s", GetSymbolValue (DEST_DIR), FileName);
2377             MakeFilePath (Str);
2378             //
2379             // Get all output directory for build output files.
2380             //
2381             Cptr = FileName + strlen (FileName) - 1;
2382             for (; (Cptr > FileName) && (*Cptr != '\\'); Cptr--);
2383             if (*Cptr == '\\') {
2384               *Cptr = '\0';
2385               AddModuleName (&gGlobals.OutdirList, FileName, NULL);
2386             }
2387           }
2388         }
2389         //
2390         // Remove file-level symbols
2391         //
2392         RemoveFileSymbols ();
2393       }
2394     }
2395   }
2396
2397   return STATUS_SUCCESS;
2398 }
2399 //
2400 // Process the INF [sources.*] sections and emit the OBJECTS = .....
2401 // lines to the component's makefile.
2402 //
2403 static
2404 int
2405 ProcessObjects (
2406   DSC_FILE  *ComponentFile,
2407   FILE      *MakeFptr
2408   )
2409 {
2410   INT8  Str[MAX_LINE_LEN];
2411   INT8  *Processor;
2412   INT8  *Platform;
2413   INT8  *SourceSelect;
2414   INT8  *CStart;
2415   INT8  *CEnd;
2416   INT8  CSave;
2417   INT8  *CopySourceSelect;
2418   SYMBOL *TempSymbol;
2419
2420   //
2421   // Write a useful comment to the output makefile so the user knows where
2422   // the data came from.
2423   //
2424   fprintf (MakeFptr, "#\n# Tool-generated list of object files that are created\n");
2425   fprintf (MakeFptr, "# from the list of source files in the [sources.*] sections\n");
2426   fprintf (MakeFptr, "# of the component INF file.\n#\n");
2427   //
2428   // We use this a lot here, so get the value only once.
2429   //
2430   Processor = GetSymbolValue (PROCESSOR);
2431   //
2432   // Now define the OBJECTS variable and assign it to be all the object files we're going
2433   // to create. Afterwards create a pseudo-target objects to let the user quickly just compile
2434   // the source files. This means we need to process all the common objects and
2435   // processor-specific objects again.
2436   //
2437   fprintf (MakeFptr, "OBJECTS = $(OBJECTS) ");
2438   //
2439   // See if they defined SOURCE_SELECT=xxx,yyy in which case well
2440   // select each [sources.xxx] and [sources.yyy] files and process
2441   // them.
2442   //
2443   SourceSelect = GetSymbolValue (SOURCE_SELECT);
2444
2445   if (SourceSelect != NULL) {
2446     //
2447     // Make a copy of the string and break it up (comma-separated) and
2448     // select each [sources.*] file from the INF.
2449     //
2450     CopySourceSelect = (INT8 *) malloc (strlen (SourceSelect) + 1);
2451     if (CopySourceSelect == NULL) {
2452       Error (NULL, 0, 0, NULL, "failed to allocate memory");
2453       return STATUS_ERROR;
2454     }
2455
2456     strcpy (CopySourceSelect, SourceSelect);
2457     CStart  = CopySourceSelect;
2458     CEnd    = CStart;
2459     while (*CStart) {
2460       CEnd = CStart + 1;
2461       while (*CEnd && *CEnd != ',') {
2462         CEnd++;
2463       }
2464
2465       CSave = *CEnd;
2466       *CEnd = 0;
2467       sprintf (Str, "%s.%s", SOURCES_SECTION_NAME, CStart);
2468       ProcessObjectsSingle (ComponentFile, MakeFptr, Str);
2469       //
2470       // Restore the terminator and advance
2471       //
2472       *CEnd   = CSave;
2473       CStart  = CEnd;
2474       if (*CStart) {
2475         CStart++;
2476       }
2477     }
2478
2479     free (CopySourceSelect);
2480
2481   } else {
2482     //
2483     // Now process all the [sources.common] files and emit build commands for them
2484     //
2485     sprintf (Str, "%s.%s", SOURCES_SECTION_NAME, COMMON_SECTION_NAME);
2486     if (ProcessObjectsSingle (ComponentFile, MakeFptr, Str) != STATUS_SUCCESS) {
2487       Warning (GetSymbolValue (INF_FILENAME), 1, 0, NULL, "no [%s] section found in component description", Str);
2488     }
2489     //
2490     // Now process any processor-specific source files in [sources.$(PROCESSOR)]
2491     //
2492     sprintf (Str, "%s.%s", SOURCES_SECTION_NAME, Processor);
2493     ProcessObjectsSingle (ComponentFile, MakeFptr, Str);
2494
2495     //
2496     // Now process any [sources.$(PROCESSOR).$(PLATFORM)] files
2497     //
2498     Platform = GetSymbolValue (PLATFORM);
2499     if (Platform != NULL) {
2500       sprintf (Str, "sources.%s.%s", Processor, Platform);
2501       ProcessObjectsSingle (ComponentFile, MakeFptr, Str);
2502     }
2503   }
2504
2505   fprintf (MakeFptr, "\n\n");
2506
2507   //
2508   // Write a useful comment to the output makefile so the user knows where
2509   // the data came from.
2510   //
2511   fprintf (MakeFptr, "#\n# Tool-generated list of dest output dirs that are created\n");
2512   fprintf (MakeFptr, "# from the list of source files in the [sources.*] sections\n");
2513   fprintf (MakeFptr, "# of the component INF file.\n#\n");
2514   //
2515   // Create output directory list
2516   // for clean target to delete all build output files.
2517   //
2518   fprintf (MakeFptr, "DEST_OUTPUT_DIRS = $(%s) ", DEST_DIR);
2519
2520   TempSymbol = gGlobals.OutdirList;
2521   while (TempSymbol != NULL) {
2522     fprintf (MakeFptr, "\\\n                   $(%s)\\%s   ",
2523              DEST_DIR, TempSymbol->Name);
2524     TempSymbol = TempSymbol->Next;
2525   }
2526   fprintf (MakeFptr, "\n\n");
2527
2528   //
2529   // clean up for the next module
2530   //
2531   FreeSymbols (gGlobals.OutdirList);
2532   gGlobals.OutdirList = NULL;
2533
2534   return STATUS_SUCCESS;
2535 }
2536
2537 static
2538 INT8 *
2539 BuiltFileExtension (
2540   INT8      *SourceFileName
2541   )
2542 {
2543   int   i;
2544   INT8  *Cptr;
2545   //
2546   // Find the dot in the filename extension
2547   //
2548   for (Cptr = SourceFileName + strlen (SourceFileName) - 1;
2549        (Cptr > SourceFileName) && (*Cptr != '\\') && (*Cptr != '.');
2550        Cptr--
2551       ) {
2552     //
2553     // Do nothing
2554     //
2555   }
2556
2557   if (*Cptr != '.') {
2558     return NULL;
2559   }
2560   //
2561   // Look through our list of known file types and return a pointer to
2562   // its built file extension.
2563   //
2564   for (i = 0; mFileTypes[i].Extension != NULL; i++) {
2565     if (_stricmp (Cptr, mFileTypes[i].Extension) == 0) {
2566       return mFileTypes[i].BuiltExtension;
2567     }
2568   }
2569
2570   return NULL;
2571 }
2572
2573 int
2574 ProcessObjectsSingle (
2575   DSC_FILE  *ComponentFile,
2576   FILE      *MakeFptr,
2577   INT8      *SectionName
2578   )
2579 {
2580   INT8    *Cptr;
2581   INT8    *Cptr2;
2582   INT8    Str[MAX_LINE_LEN];
2583   INT8    FileName[MAX_EXP_LINE_LEN];
2584   SECTION *TempSect;
2585
2586   TempSect = DSCFileFindSection (ComponentFile, SectionName);
2587   if (TempSect != NULL) {
2588     while (DSCFileGetLine (ComponentFile, Str, sizeof (Str)) != NULL) {
2589       Cptr = StripLine (Str);
2590       //
2591       // Don't process blank lines
2592       //
2593       if (*Cptr) {
2594         //
2595         // Expand symbols then create the output filename. We'll do a lookup
2596         // on the source file's extension to determine what the extension of
2597         // the built version of the file is. For example, .c -> .obj.
2598         //
2599         if (!IsIncludeFile (Cptr)) {
2600           ExpandSymbols (Cptr, FileName, sizeof (FileName), 0);
2601           ReplaceSlash (FileName);
2602           Cptr2 = BuiltFileExtension (FileName);
2603           if (Cptr2 != NULL) {
2604             SetFileExtension (FileName, Cptr2);
2605             if (!IsAbsolutePath (FileName)) {
2606               fprintf (MakeFptr, "\\\n          $(%s)\\%s   ", DEST_DIR, FileName);
2607             } else {
2608               fprintf (MakeFptr, "\\\n          %s   ", FileName);
2609             }
2610           }
2611         }
2612       }
2613     }
2614   } else {
2615     return STATUS_WARNING;
2616   }
2617
2618   return STATUS_SUCCESS;
2619 }
2620 //
2621 // Process all [libraries.*] sections in the component INF file to create a
2622 // macro to the component's output makefile: LIBS = Lib1 Lib2, ...
2623 //
2624 static
2625 int
2626 ProcessLibs (
2627   DSC_FILE  *ComponentFile,
2628   FILE      *MakeFptr
2629   )
2630 {
2631   INT8  Str[MAX_LINE_LEN];
2632   INT8  *Processor;
2633   INT8  *Platform;
2634
2635   //
2636   // Print a useful comment to the component's makefile so the user knows
2637   // where the data came from.
2638   //
2639   fprintf (MakeFptr, "#\n# Tool-generated list of libraries that are generated\n");
2640   fprintf (MakeFptr, "# from the list of libraries listed in the [libraries.*] sections\n");
2641   fprintf (MakeFptr, "# of the component INF file.\n#\n");
2642
2643   fprintf (MakeFptr, "LIBS = $(LIBS) ");
2644
2645   Processor = GetSymbolValue (PROCESSOR);
2646   //
2647   // Process [libraries.common] files
2648   //
2649   sprintf (Str, "%s.%s", LIBRARIES_SECTION_NAME, COMMON_SECTION_NAME);
2650   ProcessLibsSingle (ComponentFile, MakeFptr, Str);
2651   //
2652   // Process the [libraries.$(PROCESSOR)] libraries to define "LIBS = x.lib y.lib..."
2653   //
2654   sprintf (Str, "%s.%s", LIBRARIES_SECTION_NAME, Processor);
2655   ProcessLibsSingle (ComponentFile, MakeFptr, Str);
2656   //
2657   // Now process any [libraries.$(PROCESSOR).$(PLATFORM)] files
2658   //
2659   Platform = GetSymbolValue (PLATFORM);
2660   if (Platform != NULL) {
2661     sprintf (Str, "%s.%s.%s", LIBRARIES_SECTION_NAME, Processor, Platform);
2662     ProcessLibsSingle (ComponentFile, MakeFptr, Str);
2663   }
2664   //
2665   // Process any [libraries.platform] files
2666   //
2667   ProcessLibsSingle (ComponentFile, MakeFptr, LIBRARIES_PLATFORM_SECTION_NAME);
2668
2669   fprintf (MakeFptr, "\n\n");
2670   return STATUS_SUCCESS;
2671 }
2672
2673 static
2674 int
2675 ProcessLibsSingle (
2676   DSC_FILE  *ComponentFile,
2677   FILE      *MakeFptr,
2678   INT8      *SectionName
2679   )
2680 {
2681   INT8    *Cptr;
2682   INT8    Str[MAX_LINE_LEN];
2683   INT8    ExpandedLine[MAX_LINE_LEN];
2684   SECTION *TempSect;
2685
2686   TempSect = DSCFileFindSection (ComponentFile, SectionName);
2687   if (TempSect != NULL) {
2688     while (DSCFileGetLine (ComponentFile, Str, sizeof (Str)) != NULL) {
2689       ExpandSymbols (Str, ExpandedLine, sizeof (ExpandedLine), 0);
2690       Cptr = StripLine (ExpandedLine);
2691       //
2692       // Don't process blank lines
2693       //
2694       if (*Cptr) {
2695         if (Cptr[strlen (Cptr) - 4] != '.') {
2696           fprintf (MakeFptr, "    \\\n       $(LIB_DIR)\\%s.lib", Cptr);
2697           //
2698           // Add lib dependency for single module build
2699           //
2700           fprintf (gGlobals.ModuleMakefileFptr, " %sbuild", Cptr);
2701         } else {
2702           fprintf (MakeFptr, "    \\\n       $(LIB_DIR)\\%s", Cptr);
2703           //
2704           // Add lib dependency for single module build
2705           //
2706           Cptr[strlen (Cptr) - 4] = 0;
2707           fprintf (gGlobals.ModuleMakefileFptr, " %sbuild", Cptr);
2708         }
2709         //
2710         // Add libs dependency for mCurrentBuildItem
2711         //
2712         AddDependency (*mCurrentBuildList, mCurrentBuildItem, Cptr, 0);
2713       }
2714     }
2715   }
2716
2717   return STATUS_SUCCESS;
2718 }
2719
2720 static
2721 int
2722 ProcessIncludeFiles (
2723   DSC_FILE *ComponentFile,
2724   FILE     *MakeFptr
2725   )
2726 {
2727   INT8  Str[MAX_LINE_LEN];
2728   INT8  *Processor;
2729   INT8  *Platform;
2730   INT8  *SourceSelect;
2731   INT8  *CStart;
2732   INT8  *CEnd;
2733   INT8  CSave;
2734   INT8  *CopySourceSelect;
2735
2736   //
2737   // Print a useful comment to the output makefile so the user knows where
2738   // the info came from
2739   //
2740   //fprintf (MakeFptr, "#\n# Tool-generated include dependencies from any include files in the\n");
2741   //fprintf (MakeFptr, "# [sources.*] sections of the component INF file\n#\n");
2742
2743   Processor = GetSymbolValue (PROCESSOR);
2744
2745   //
2746   // See if they defined SOURCE_SELECT=xxx,yyy in which case we'll
2747   // select each [sources.xxx] and [sources.yyy] files and process
2748   // them.
2749   //
2750   SourceSelect = GetSymbolValue (SOURCE_SELECT);
2751
2752   if (SourceSelect != NULL) {
2753     //
2754     // Make a copy of the string and break it up (comma-separated) and
2755     // select each [sources.*] file from the INF.
2756     //
2757     CopySourceSelect = (INT8 *) malloc (strlen (SourceSelect) + 1);
2758     if (CopySourceSelect == NULL) {
2759       Error (NULL, 0, 0, NULL, "failed to allocate memory");
2760       return STATUS_ERROR;
2761     }
2762
2763     strcpy (CopySourceSelect, SourceSelect);
2764     CStart  = CopySourceSelect;
2765     CEnd    = CStart;
2766     while (*CStart) {
2767       CEnd = CStart + 1;
2768       while (*CEnd && *CEnd != ',') {
2769         CEnd++;
2770       }
2771
2772       CSave = *CEnd;
2773       *CEnd = 0;
2774       sprintf (Str, "%s.%s", SOURCES_SECTION_NAME, CStart);
2775       ProcessIncludeFilesSingle (ComponentFile, MakeFptr, Str);
2776       //
2777       // Restore the terminator and advance
2778       //
2779       *CEnd   = CSave;
2780       CStart  = CEnd;
2781       if (*CStart) {
2782         CStart++;
2783       }
2784     }
2785
2786     free (CopySourceSelect);
2787
2788   } else {
2789     //
2790     // Find all the include files in the [sources.common] sections.
2791     //
2792     sprintf (Str, "%s.%s", SOURCES_SECTION_NAME, COMMON_SECTION_NAME);
2793     ProcessIncludeFilesSingle (ComponentFile, MakeFptr, Str);
2794     //
2795     // Now process the [sources.$(PROCESSOR)] files.
2796     //
2797     sprintf (Str, "%s.%s", SOURCES_SECTION_NAME, Processor);
2798     ProcessIncludeFilesSingle (ComponentFile, MakeFptr, Str);
2799     //
2800     // Now process the [sources.$(PROCESSOR).$(PLATFORM)] files.
2801     //
2802     Platform = GetSymbolValue (PLATFORM);
2803     if (Platform != NULL) {
2804       sprintf (Str, "sources.%s.%s", Processor, Platform);
2805       ProcessIncludeFilesSingle (ComponentFile, MakeFptr, Str);
2806     }
2807   }
2808
2809   fprintf (MakeFptr, "\n");
2810   return STATUS_SUCCESS;
2811 }
2812
2813 int
2814 ProcessIncludeFilesSingle (
2815   DSC_FILE  *ComponentFile,
2816   FILE      *MakeFptr,
2817   INT8      *SectionName
2818   )
2819 {
2820   INT8            *Cptr;
2821   INT8            FileName[MAX_EXP_LINE_LEN];
2822   INT8            TempFileName[MAX_PATH];
2823   SECTION         *TempSect;
2824   INT8            Str[MAX_LINE_LEN];
2825   INT8            *OverridePath;
2826   FILE            *FPtr;
2827
2828   TempSect = DSCFileFindSection (ComponentFile, SectionName);
2829   if (TempSect != NULL) {
2830     //
2831     // See if the SOURCE_OVERRIDE_PATH has been set. If it has, and
2832     // they have an include file that is overridden, then add the path
2833     // to it to the list of include paths (prepend).
2834     //
2835     OverridePath = GetSymbolValue (SOURCE_OVERRIDE_PATH);
2836     while (DSCFileGetLine (ComponentFile, Str, sizeof (Str)) != NULL) {
2837       Cptr = StripLine (Str);
2838       //
2839       // Don't process blank lines
2840       //
2841       if (*Cptr) {
2842         //
2843         // Expand symbols in the filename, then get its parts
2844         //
2845         ExpandSymbols (Cptr, FileName, sizeof (FileName), 0);
2846         AddFileSymbols (FileName);
2847         ReplaceSlash (FileName);
2848         if (IsIncludeFile (FileName)) {
2849           if ((OverridePath != NULL) && (!IsAbsolutePath (FileName))) {
2850             ReplaceSlash (OverridePath);
2851             strcpy (TempFileName, OverridePath);
2852             strcat (TempFileName, "\\");
2853             strcat (TempFileName, FileName);
2854             if ((FPtr = fopen (TempFileName, "rb")) != NULL) {
2855               fclose (FPtr);
2856               //
2857               // Null-terminate the file name at the last backslash and add that
2858               // to the beginning of the list of include paths.
2859               //
2860               for (Cptr = TempFileName + strlen (TempFileName) - 1;
2861                    (Cptr >= TempFileName) && (*Cptr != '\\');
2862                    Cptr--
2863                   )
2864                 ;
2865               if (Cptr >= TempFileName) {
2866                 *Cptr = 0;
2867               }
2868               fprintf (MakeFptr, "!IF EXIST(%s)\n", TempFileName);
2869               fprintf (MakeFptr, "INC = -I %s $(INC)\n", TempFileName);
2870               fprintf (MakeFptr, "!ENDIF\n");
2871             }
2872           }
2873           //
2874           // If absolute path already, don't prepend source directory
2875           //
2876           // if (IsAbsolutePath (FileName)) {
2877           //   fprintf (MakeFptr, "INC_DEPS = $(INC_DEPS) %s\n", FileName);
2878           // } else {
2879           //   fprintf (MakeFptr, "INC_DEPS = $(INC_DEPS) $(SOURCE_DIR)\\%s\n", FileName);
2880           // }
2881         }
2882
2883         RemoveFileSymbols ();
2884       }
2885     }
2886   }
2887
2888   return STATUS_SUCCESS;
2889 }
2890
2891 static
2892 void
2893 FreeFileParts (
2894   FILE_NAME_PARTS *FP
2895   )
2896 {
2897   if (FP != NULL) {
2898     if (FP->Path != NULL) {
2899       free (FP->Path);
2900     }
2901
2902     if (FP->BaseName != NULL) {
2903       free (FP->BaseName);
2904     }
2905
2906     if (FP->Extension != NULL) {
2907       free (FP->Extension);
2908     }
2909   }
2910 }
2911
2912 static
2913 FILE_NAME_PARTS *
2914 GetFileParts (
2915   INT8 *FileName
2916   )
2917 {
2918   FILE_NAME_PARTS *FP;
2919   INT8            *Cptr;
2920   INT8            CopyFileName[MAX_PATH];
2921   INT8            *FileNamePtr;
2922
2923   strcpy (CopyFileName, FileName);
2924   FP = (FILE_NAME_PARTS *) malloc (sizeof (FILE_NAME_PARTS));
2925   if (FP == NULL) {
2926     Error (NULL, 0, 0, NULL, "failed to allocate memory");
2927     return NULL;
2928   }
2929
2930   memset ((INT8 *) FP, 0, sizeof (FILE_NAME_PARTS));
2931   //
2932   // Get extension code
2933   //
2934   FP->ExtensionCode = GetSourceFileType (CopyFileName);
2935   //
2936   // Get drive if there
2937   //
2938   FileNamePtr = CopyFileName;
2939   if (FileNamePtr[1] == ':') {
2940     FP->Drive[0]  = FileNamePtr[0];
2941     FP->Drive[1]  = ':';
2942     FileNamePtr += 2;
2943   }
2944   //
2945   // Start at the end and work back
2946   //
2947   for (Cptr = FileNamePtr + strlen (FileNamePtr) - 1; (Cptr > FileNamePtr) && (*Cptr != '.'); Cptr--)
2948     ;
2949
2950   if (*Cptr == '.') {
2951     //
2952     // Don't copy the dot
2953     //
2954     FP->Extension = (char *) malloc (strlen (Cptr));
2955     strcpy (FP->Extension, Cptr + 1);
2956     *Cptr = 0;
2957     Cptr--;
2958     StripTrailingSpaces (FP->Extension);
2959   } else {
2960     //
2961     // Create empty string for extension
2962     //
2963     FP->Extension     = (char *) malloc (1);
2964     FP->Extension[0]  = 0;
2965   }
2966   //
2967   // Now back up and get the base name (include the preceding '\')
2968   //
2969   for (; (Cptr > FileNamePtr) && (*Cptr != '\\'); Cptr--)
2970     ;
2971   FP->BaseName = (char *) malloc (strlen (Cptr) + 1);
2972   strcpy (FP->BaseName, Cptr);
2973   *Cptr = 0;
2974   Cptr--;
2975   //
2976   // Rest is path
2977   //
2978   if (Cptr >= FileNamePtr) {
2979     Cptr      = FileNamePtr;
2980     FP->Path  = (char *) malloc (strlen (Cptr) + 1);
2981     strcpy (FP->Path, Cptr);
2982   } else {
2983     FP->Path    = (char *) malloc (1);
2984     FP->Path[0] = 0;
2985   }
2986
2987   return FP;
2988 }
2989
2990 /*****************************************************************************
2991 ******************************************************************************/
2992 static
2993 int
2994 WriteCommonMakefile (
2995   DSC_FILE  *DSCFile,
2996   FILE      *MakeFptr,
2997   INT8      *Processor
2998   )
2999 {
3000   INT8    InLine[MAX_LINE_LEN];
3001   INT8    OutLine[MAX_EXP_LINE_LEN];
3002   SECTION *Sect;
3003   INT8    *Sym;
3004   int     i;
3005   //
3006   // Don't mess up the original file pointer, since we're processing it at a higher
3007   // level.
3008   //
3009   DSCFileSavePosition (DSCFile);
3010   //
3011   // Write the header to the file
3012   //
3013   for (i = 0; MakefileHeader[i] != NULL; i++) {
3014     fprintf (MakeFptr, "%s\n", MakefileHeader[i]);
3015   }
3016
3017   fprintf (MakeFptr, "#\n# Hard-coded defines output by the tool\n#\n");
3018   //
3019   // First write the basics to the component's makefile. These includes
3020   // EFI_SOURCE, BIN_DIR, OUT_DIR, LIB_DIR, SOURCE_DIR, DEST_DIR.
3021   //
3022   Sym = GetSymbolValue (EFI_SOURCE);
3023   fprintf (MakeFptr, "%s       = %s\n", EFI_SOURCE, Sym);
3024   Sym = GetSymbolValue (BUILD_DIR);
3025   fprintf (MakeFptr, "%s        = %s\n", BUILD_DIR, Sym);
3026   Sym = GetSymbolValue (BIN_DIR);
3027   fprintf (MakeFptr, "%s          = %s\n", BIN_DIR, Sym);
3028   Sym = GetSymbolValue (OUT_DIR);
3029   fprintf (MakeFptr, "%s          = %s\n", OUT_DIR, Sym);
3030   Sym = GetSymbolValue (LIB_DIR);
3031   fprintf (MakeFptr, "%s          = %s\n", LIB_DIR, Sym);
3032   Sym = GetSymbolValue (SOURCE_DIR);
3033   fprintf (MakeFptr, "%s       = %s\n", SOURCE_DIR, Sym);
3034   Sym = GetSymbolValue (DEST_DIR);
3035   fprintf (MakeFptr, "%s         = %s\n", DEST_DIR, Sym);
3036   fprintf (MakeFptr, "\n");
3037   //
3038   // If there was a [makefile.common] section in the description file,
3039   // copy it (after symbol expansion) to the output file.
3040   //
3041   sprintf (InLine, "%s.%s", MAKEFILE_SECTION_NAME, COMMON_SECTION_NAME);
3042   Sect = DSCFileFindSection (DSCFile, InLine);
3043   if (Sect != NULL) {
3044     //
3045     // fprintf (MakeFptr, "# From the [makefile.common] section of the DSC file\n");
3046     // Read lines, expand, then dump out
3047     //
3048     while (DSCFileGetLine (DSCFile, InLine, sizeof (InLine)) != NULL) {
3049       //
3050       // Replace symbols
3051       //
3052       ExpandSymbols (InLine, OutLine, sizeof (OutLine), EXPANDMODE_RECURSIVE);
3053       fprintf (MakeFptr, OutLine);
3054     }
3055   }
3056   //
3057   // If there was a [makefile.platform] section in the description file,
3058   // copy it (after symbol expansion) to the output file.
3059   //
3060   sprintf (InLine, "%s.%s", MAKEFILE_SECTION_NAME, "Platform");
3061   Sect = DSCFileFindSection (DSCFile, InLine);
3062   if (Sect != NULL) {
3063     //
3064     // Read lines, expand, then dump out
3065     //
3066     while (DSCFileGetLine (DSCFile, InLine, sizeof (InLine)) != NULL) {
3067       //
3068       // Replace symbols
3069       //
3070       ExpandSymbols (InLine, OutLine, sizeof (OutLine), EXPANDMODE_RECURSIVE);
3071       fprintf (MakeFptr, OutLine);
3072     }
3073   }
3074   //
3075   // Do the same for any [makefile.$(PROCESSOR)]
3076   //
3077   sprintf (InLine, "%s.%s", MAKEFILE_SECTION_NAME, Processor);
3078   Sect = DSCFileFindSection (DSCFile, InLine);
3079   if (Sect != NULL) {
3080     //
3081     // Read lines, expand, then dump out
3082     //
3083     while (DSCFileGetLine (DSCFile, InLine, sizeof (InLine)) != NULL) {
3084       ExpandSymbols (InLine, OutLine, sizeof (OutLine), EXPANDMODE_RECURSIVE);
3085       fprintf (MakeFptr, OutLine);
3086     }
3087   }
3088   //
3089   // Same thing for [makefile.$(PROCESSOR).$(PLATFORM)]
3090   //
3091   Sym = GetSymbolValue (PLATFORM);
3092   if (Sym != NULL) {
3093     sprintf (InLine, "%s.%s.%s", MAKEFILE_SECTION_NAME, Processor, Sym);
3094     Sect = DSCFileFindSection (DSCFile, InLine);
3095     if (Sect != NULL) {
3096       //
3097       // Read lines, expand, then dump out
3098       //
3099       while (DSCFileGetLine (DSCFile, InLine, sizeof (InLine)) != NULL) {
3100         ExpandSymbols (InLine, OutLine, sizeof (OutLine), EXPANDMODE_RECURSIVE);
3101         fprintf (MakeFptr, OutLine);
3102       }
3103     }
3104   }
3105
3106   fprintf (MakeFptr, "\n");
3107   DSCFileRestorePosition (DSCFile);
3108   return 0;
3109 }
3110
3111 static
3112 int
3113 WriteComponentTypeBuildCommands (
3114   DSC_FILE *DSCFile,
3115   FILE     *MakeFptr,
3116   INT8     *SectionName
3117   )
3118 /*++
3119
3120 Routine Description:
3121
3122    Given a section name such as [build.ia32.library], find the section in
3123    the description file and copy the build commands.
3124
3125 Arguments:
3126
3127   DSCFile     - section information on the main description file
3128   MakeFptr    - file pointer to the makefile we're writing to
3129   SectionName - name of the section we're to copy out to the makefile.
3130
3131 Returns:
3132
3133   Always successful, since the section may be optional.
3134
3135 --*/
3136 {
3137   SECTION *Sect;
3138   INT8    InLine[MAX_LINE_LEN];
3139   INT8    OutLine[MAX_EXP_LINE_LEN];
3140
3141   //
3142   // Don't mess up the original file pointer, since we're processing it at a higher
3143   // level.
3144   //
3145   DSCFileSavePosition (DSCFile);
3146   Sect = DSCFileFindSection (DSCFile, SectionName);
3147   if (Sect != NULL) {
3148     //
3149     // Read lines, expand, then dump out
3150     //
3151     while (DSCFileGetLine (DSCFile, InLine, sizeof (InLine)) != NULL) {
3152       ExpandSymbols (
3153         InLine,
3154         OutLine,
3155         sizeof(OutLine),
3156         EXPANDMODE_NO_DESTDIR | EXPANDMODE_NO_SOURCEDIR
3157         );
3158       fprintf (MakeFptr, OutLine);
3159     }
3160   } else {
3161     Warning (
3162       NULL,
3163       0,
3164       0,
3165       GetSymbolValue (INF_FILENAME),
3166       "no [%s] build commands found in DSC file for component",
3167       SectionName
3168       );
3169   }
3170
3171   DSCFileRestorePosition (DSCFile);
3172   return STATUS_SUCCESS;
3173 }
3174
3175 /*****************************************************************************
3176
3177 ******************************************************************************/
3178 static
3179 int
3180 WriteCompileCommands (
3181   DSC_FILE  *DscFile,
3182   FILE      *MakeFptr,
3183   INT8      *FileName,
3184   INT8      *Processor
3185   )
3186 {
3187   FILE_NAME_PARTS *File;
3188   SECTION         *Sect;
3189   INT8            BuildSectionName[40];
3190   INT8            InLine[MAX_LINE_LEN];
3191   INT8            OutLine[MAX_EXP_LINE_LEN];
3192   INT8            *SourceCompileType;
3193   char            *CPtr;
3194   char            *CPtr2;
3195   //
3196   // Determine the filename, then chop it up into its parts
3197   //
3198   File = GetFileParts (FileName);
3199   if (File != NULL) {
3200     //
3201     // Don't mess up the original file pointer, since we're processing it at a higher
3202     // level.
3203     //
3204     DSCFileSavePosition (DscFile);
3205     //
3206     // Option 1: SOURCE_COMPILE_TYPE=MyCompileSection
3207     //           Find a section of that name from which to get the compile
3208     //           commands for this source file.
3209     //           Look for [compile.$(PROCESSOR).$(SOURCE_COMPILE_TYPE]
3210     // Option 2: COMPILE_SELECT=.c=MyCCompile,.asm=MyAsm
3211     //           Find a [compile.$(PROCESSOR).MyCompile] section from which to
3212     //           get the compile commands for this source file.
3213     //           Look for [compile.$(PROCESSOR).MyCompile]
3214     // Option 3: Look for standard section types to compile the file by extension.
3215     //           Look for [compile.$(PROCESSOR).<extension>]
3216     //
3217     Sect = NULL;
3218     //
3219     // Option 1 - use SOURCE_COMPILE_TYPE variable
3220     //
3221     SourceCompileType = GetSymbolValue (SOURCE_COMPILE_TYPE);
3222     if (SourceCompileType != NULL) {
3223       sprintf (BuildSectionName, "compile.%s.%s", Processor, SourceCompileType);
3224       Sect = DSCFileFindSection (DscFile, BuildSectionName);
3225     }
3226     //
3227     // Option 2 - use COMPILE_SELECT variable
3228     //
3229     if (Sect == NULL) {
3230       SourceCompileType = GetSymbolValue (COMPILE_SELECT);
3231       if (SourceCompileType != NULL) {
3232         //
3233         // Parse the variable, which looks like COMPILE_SELECT=.c=MyCCompiler;.asm=MyAsm;
3234         // to find an entry with a matching file name extension. If you find one,
3235         // then use that name to find the section name.
3236         //
3237         CPtr = SourceCompileType;
3238         while (*CPtr && (Sect == NULL)) {
3239           //
3240           // See if we found a match with this source file name extension. File->Extension
3241           // does not include the dot, so skip the dot in the COMPILE_SELECT variable if there
3242           // is one.
3243           //
3244           if (*CPtr == '.') {
3245             CPtr++;
3246           }
3247
3248           if (_strnicmp (CPtr, File->Extension, strlen (File->Extension)) == 0) {
3249             //
3250             // Found a file name extension match -- extract the name from the variable, for
3251             // example "MyCCompiler"
3252             //
3253             while (*CPtr && (*CPtr != '=')) {
3254               CPtr++;
3255             }
3256
3257             if ((*CPtr != '=') || (CPtr[1] == 0)) {
3258               Error (NULL, 0, 0, SourceCompileType, "malformed COMPILE_SELECT variable");
3259               break;
3260             }
3261
3262             CPtr++;
3263             sprintf (BuildSectionName, "compile.%s.", Processor);
3264             for (CPtr2 = BuildSectionName + strlen (BuildSectionName);
3265                  *CPtr && (*CPtr != ',') && (*CPtr != ';');
3266                  CPtr++
3267                 ) {
3268               *CPtr2 = *CPtr;
3269               CPtr2++;
3270             }
3271
3272             *CPtr2  = 0;
3273             Sect    = DSCFileFindSection (DscFile, BuildSectionName);
3274             if (Sect == NULL) {
3275               ParserError (
3276                 0,
3277                 BuildSectionName,
3278                 "could not find section in DSC file - selected by COMPILE_SELECT variable"
3279                 );
3280             }
3281           }
3282
3283           //
3284           // Skip to next file name extension in the COMPILE_SELECT variable
3285           //
3286           while (*CPtr && (*CPtr != ';') && (*CPtr != ',')) {
3287             CPtr++;
3288           }
3289
3290           if (*CPtr) {
3291             CPtr++;
3292           }
3293         }
3294       }
3295     }
3296     //
3297     // Option 3 - use "Compile.$(PROCESSOR).<Extension>" section
3298     //
3299     if (Sect == NULL) {
3300       sprintf (BuildSectionName, "compile.%s.%s", Processor, File->Extension);
3301       Sect = DSCFileFindSection (DscFile, BuildSectionName);
3302     }
3303     //
3304     // Should have found something by now unless it's an include (.h) file
3305     //
3306     if (Sect != NULL) {
3307       //
3308       // Temporarily add a FILE variable to the global symbol table. Omit the
3309       // extension.
3310       //
3311       sprintf (InLine, "%s%s%s", File->Drive, File->Path, File->BaseName);
3312       AddSymbol ("FILE", InLine, SYM_OVERWRITE | SYM_LOCAL | SYM_FILENAME);
3313       //
3314       // Read lines, expand (except SOURCE_DIR and DEST_DIR), then dump out
3315       //
3316       while (DSCFileGetLine (DscFile, InLine, sizeof (InLine)) != NULL) {
3317         ExpandSymbols (
3318           InLine,
3319           OutLine,
3320           sizeof (OutLine),
3321           EXPANDMODE_NO_DESTDIR | EXPANDMODE_NO_SOURCEDIR
3322           );
3323         fprintf (MakeFptr, OutLine);
3324       }
3325       fprintf (MakeFptr, "\n");
3326     } else {
3327       //
3328       // Be nice and ignore include files
3329       //
3330       if (!IsIncludeFile (FileName)) {
3331         Error (
3332           NULL,
3333           0,
3334           0,
3335           NULL,
3336           "no compile commands section [%s] found in DSC file for %s",
3337           BuildSectionName,
3338           FileName
3339           );
3340       }
3341     }
3342
3343     DSCFileRestorePosition (DscFile);
3344     FreeFileParts (File);
3345   }
3346
3347   return STATUS_SUCCESS;
3348 }
3349
3350 /*****************************************************************************
3351 ******************************************************************************/
3352 static
3353 int
3354 SetFileExtension (
3355   INT8 *FileName,
3356   INT8 *Extension
3357   )
3358 {
3359   INT8  *Cptr;
3360
3361   Cptr = FileName + strlen (FileName) - 1;
3362   while ((Cptr > FileName) && (*Cptr != '.')) {
3363     Cptr--;
3364
3365   }
3366   //
3367   // Better be a dot
3368   //
3369   if (*Cptr != '.') {
3370     Message (2, "Missing filename extension: %s", FileName);
3371     return STATUS_WARNING;
3372   }
3373
3374   Cptr++;
3375   if (*Extension == '.') {
3376     Extension++;
3377   }
3378
3379   strcpy (Cptr, Extension);
3380   return STATUS_SUCCESS;
3381 }
3382
3383 /*****************************************************************************
3384 ******************************************************************************/
3385 int
3386 MakeFilePath (
3387   INT8 *FileName
3388   )
3389 {
3390   INT8  *Cptr;
3391   INT8  SavedChar;
3392   INT8  BuildDir[MAX_PATH];
3393   INT8  CopyFileName[MAX_PATH];
3394
3395   //
3396   // Expand symbols in the filename
3397   //
3398   if (ExpandSymbols (FileName, CopyFileName, sizeof (CopyFileName), EXPANDMODE_NO_UNDEFS)) {
3399     Error (NULL, 0, 0, NULL, "undefined symbols in file path: %s", FileName);
3400     return STATUS_ERROR;
3401   }
3402   //
3403   // Copy it back
3404   //
3405   strcpy (FileName, CopyFileName);
3406   //
3407   // To avoid creating $(BUILD_DIR) path, see if this path is the same as
3408   // $(BUILD_DIR), and if it is, see if build dir exists and skip over that
3409   // portion if it does
3410   //
3411   Cptr = GetSymbolValue (BUILD_DIR);
3412   if (Cptr != NULL) {
3413     if (_strnicmp (Cptr, FileName, strlen (Cptr)) == 0) {
3414       //
3415       // BUILD_DIR path. See if it exists
3416       //
3417       strcpy (BuildDir, FileName);
3418       BuildDir[strlen (Cptr)] = 0;
3419       if ((_mkdir (BuildDir) != 0) && (errno != EEXIST)) {
3420         Cptr = FileName;
3421       } else {
3422         //
3423         // Already done. Shortcut. Skip to next path so that we don't create
3424         // the BUILD_DIR as well.
3425         //
3426         Cptr = FileName + strlen (Cptr);
3427         if (*Cptr == '\\') {
3428           Cptr++;
3429         }
3430       }
3431     } else {
3432       //
3433       // Not build dir
3434       //
3435       Cptr = FileName;
3436     }
3437   } else {
3438     Cptr = FileName;
3439   }
3440   //
3441   // Create directories until done. Skip over "c:\" in the path if it exists
3442   //
3443   if (*Cptr && (*(Cptr + 1) == ':') && (*(Cptr + 2) == '\\')) {
3444     Cptr += 3;
3445   }
3446
3447   for (;;) {
3448     for (; *Cptr && (*Cptr != '\\'); Cptr++)
3449       ;
3450     if (*Cptr) {
3451       SavedChar = *Cptr;
3452       *Cptr     = 0;
3453       if ((_mkdir (FileName) != 0)) {
3454         //
3455         //        Error (NULL, 0, 0, FileName, "failed to create directory");
3456         //        return 1;
3457         //
3458       }
3459
3460       *Cptr = SavedChar;
3461       Cptr++;
3462     } else {
3463       break;
3464     }
3465   }
3466
3467   return STATUS_SUCCESS;
3468 }
3469
3470 /*****************************************************************************
3471 ******************************************************************************/
3472 int
3473 ExpandSymbols (
3474   INT8  *SourceLine,
3475   INT8  *DestLine,
3476   int   LineLen,
3477   int   ExpandMode
3478   )
3479 {
3480   static int  NestDepth = 0;
3481   INT8        *FromPtr;
3482   INT8        *ToPtr;
3483   INT8        *SaveStart;
3484   INT8        *Cptr;
3485   INT8        *value;
3486   int         Expanded;
3487   int         ExpandedCount;
3488   INT8        *LocalDestLine;
3489   STATUS      Status;
3490   int         LocalLineLen;
3491
3492   NestDepth++;
3493   Status        = STATUS_SUCCESS;
3494   LocalDestLine = (INT8 *) malloc (LineLen);
3495   if (LocalDestLine == NULL) {
3496     Error (__FILE__, __LINE__, 0, "application error", "memory allocation failed");
3497     NestDepth = 0;
3498     return STATUS_ERROR;
3499   }
3500
3501   FromPtr = SourceLine;
3502   ToPtr   = LocalDestLine;
3503   //
3504   // Walk the entire line, replacing $(SYMBOL_NAME).
3505   //
3506   LocalLineLen  = LineLen;
3507   ExpandedCount = 0;
3508   while (*FromPtr && (LocalLineLen > 0)) {
3509     if ((*FromPtr == '$') && (*(FromPtr + 1) == '(')) {
3510       //
3511       // Save the start in case it's undefined, in which case we copy it as-is.
3512       //
3513       SaveStart = FromPtr;
3514       Expanded  = 0;
3515       //
3516       // Symbol expansion time. Find the end (no spaces allowed)
3517       //
3518       FromPtr += 2;
3519       for (Cptr = FromPtr; *Cptr && (*Cptr != ')'); Cptr++)
3520         ;
3521       if (*Cptr) {
3522         //
3523         // Truncate the string at the closing parenthesis for ease-of-use.
3524         // Then copy the string directly to the destination line in case we don't find
3525         // a definition for it.
3526         //
3527         *Cptr = 0;
3528         strcpy (ToPtr, SaveStart);
3529         if ((_stricmp (SOURCE_DIR, FromPtr) == 0) && (ExpandMode & EXPANDMODE_NO_SOURCEDIR)) {
3530           //
3531           // excluded this expansion
3532           //
3533         } else if ((_stricmp (DEST_DIR, FromPtr) == 0) && (ExpandMode & EXPANDMODE_NO_DESTDIR)) {
3534           //
3535           // excluded this expansion
3536           //
3537         } else if ((value = GetSymbolValue (FromPtr)) != NULL) {
3538           strcpy (ToPtr, value);
3539           LocalLineLen -= strlen (value);
3540           ToPtr += strlen (value);
3541           Expanded = 1;
3542           ExpandedCount++;
3543         } else if (ExpandMode & EXPANDMODE_NO_UNDEFS) {
3544           Error (NULL, 0, 0, "undefined symbol", "$(%s)", FromPtr);
3545           Status = STATUS_ERROR;
3546           goto Done;
3547         }
3548
3549         //
3550         // Restore closing parenthesis, and advance to next character
3551         //
3552         *Cptr   = ')';
3553         if (!Expanded) {
3554           FromPtr = SaveStart + 1;
3555           ToPtr++;
3556         } else {
3557           FromPtr = Cptr + 1;
3558         }
3559       } else {
3560         Error (NULL, 0, 0, SourceLine, "missing closing parenthesis on symbol");
3561         strcpy (ToPtr, FromPtr);
3562         Status = STATUS_WARNING;
3563         goto Done;
3564       }
3565     } else {
3566       *ToPtr = *FromPtr;
3567       FromPtr++;
3568       ToPtr++;
3569       LocalLineLen--;
3570     }
3571   }
3572
3573   if (*FromPtr == 0) {
3574     *ToPtr = 0;
3575   }
3576
3577   //
3578   // If we're in recursive mode, and we expanded at least one string successfully,
3579   // then make a recursive call to try again.
3580   //
3581   if ((ExpandedCount != 0) && (Status == STATUS_SUCCESS) && (ExpandMode & EXPANDMODE_RECURSIVE) && (NestDepth < 2)) {
3582     Status = ExpandSymbols (LocalDestLine, DestLine, LineLen, ExpandMode);
3583     free (LocalDestLine);
3584     NestDepth = 0;
3585     return Status;
3586   }
3587
3588 Done:
3589   if (Status != STATUS_ERROR) {
3590     strcpy (DestLine, LocalDestLine);
3591   }
3592
3593   NestDepth = 0;
3594   free (LocalDestLine);
3595   return Status;
3596 }
3597
3598 INT8 *
3599 GetSymbolValue (
3600   INT8 *SymbolName
3601   )
3602 /*++
3603
3604 Routine Description:
3605
3606   Look up a symbol in our symbol table.
3607
3608 Arguments:
3609
3610   SymbolName - The name of symbol.
3611
3612 Returns:
3613
3614   Pointer to the value of the symbol if found
3615   NULL if the symbol is not found
3616
3617 --*/
3618 {
3619   SYMBOL  *Symbol;
3620
3621   //
3622   // Scan once for file-level symbols
3623   //
3624   Symbol = gGlobals.Symbol;
3625   while (Symbol) {
3626     if ((_stricmp (SymbolName, Symbol->Name) == 0) && (Symbol->Type & SYM_FILE)) {
3627       return Symbol->Value;
3628     }
3629
3630     Symbol = Symbol->Next;
3631   }
3632   //
3633   // Scan once for local symbols
3634   //
3635   Symbol = gGlobals.Symbol;
3636   while (Symbol) {
3637     if ((_stricmp (SymbolName, Symbol->Name) == 0) && (Symbol->Type & SYM_LOCAL)) {
3638       return Symbol->Value;
3639     }
3640
3641     Symbol = Symbol->Next;
3642   }
3643   //
3644   // No local value found. Scan for globals.
3645   //
3646   Symbol = gGlobals.Symbol;
3647   while (Symbol) {
3648     if ((_stricmp (SymbolName, Symbol->Name) == 0) && (Symbol->Type & SYM_GLOBAL)) {
3649       return Symbol->Value;
3650     }
3651
3652     Symbol = Symbol->Next;
3653   }
3654   //
3655   // For backwards-compatibility, if it's "GUID", return FILE_GUID value
3656   //
3657   if (_stricmp (SymbolName, GUID) == 0) {
3658     return GetSymbolValue (FILE_GUID);
3659   }
3660
3661   return NULL;
3662 }
3663
3664 static
3665 int
3666 RemoveLocalSymbols (
3667   VOID
3668   )
3669 /*++
3670
3671 Routine Description:
3672
3673   Remove all local symbols from the symbol table. Local symbols are those
3674   that are defined typically by the component's INF file.
3675
3676 Arguments:
3677
3678   None.
3679
3680 Returns:
3681
3682   Right now, never fails.
3683
3684 --*/
3685 {
3686   SYMBOL  *Sym;
3687   int     FoundOne;
3688
3689   do {
3690     FoundOne  = 0;
3691     Sym       = gGlobals.Symbol;
3692     while (Sym) {
3693       if (Sym->Type & SYM_LOCAL) {
3694         //
3695         // Going to delete it out from under ourselves, so break and restart
3696         //
3697         FoundOne = 1;
3698         RemoveSymbol (Sym->Name, SYM_LOCAL);
3699         break;
3700       }
3701
3702       Sym = Sym->Next;
3703     }
3704   } while (FoundOne);
3705   return STATUS_SUCCESS;
3706 }
3707
3708 static
3709 int
3710 RemoveFileSymbols (
3711   VOID
3712   )
3713 /*++
3714
3715 Routine Description:
3716
3717   Remove all file-level symbols from the symbol table. File-level symbols are
3718   those that are defined on a source file line in an INF file.
3719
3720 Arguments:
3721
3722   None.
3723
3724 Returns:
3725
3726   Right now, never fails.
3727
3728 --*/
3729 {
3730   SYMBOL  *Sym;
3731   int     FoundOne;
3732
3733   do {
3734     FoundOne  = 0;
3735     Sym       = gGlobals.Symbol;
3736     while (Sym) {
3737       if (Sym->Type & SYM_FILE) {
3738         //
3739         // Going to delete it out from under ourselves, so break and restart
3740         //
3741         FoundOne = 1;
3742         RemoveSymbol (Sym->Name, SYM_FILE);
3743         break;
3744       }
3745
3746       Sym = Sym->Next;
3747     }
3748   } while (FoundOne);
3749   return STATUS_SUCCESS;
3750 }
3751
3752 static
3753 STATUS
3754 ParseGuidDatabaseFile (
3755   INT8 *FileName
3756   )
3757 /*++
3758
3759 Routine Description:
3760   This function parses a GUID-to-basename text file (perhaps output by
3761   the GuidChk utility) to define additional symbols. The format of the
3762   file should be:
3763
3764   7BB28B99-61BB-11D5-9A5D-0090273FC14D EFI_DEFAULT_BMP_LOGO_GUID gEfiDefaultBmpLogoGuid
3765
3766   This function parses the line and defines global symbol:
3767
3768     EFI_DEFAULT_BMP_LOGO_GUID=7BB28B99-61BB-11D5-9A5D-0090273FC14D
3769
3770   This symbol (rather than the actual GUID) can then be used in INF files to
3771   fix duplicate GUIDs
3772
3773 Arguments:
3774   FileName  - the name of the file to parse.
3775
3776 Returns:
3777   STATUS_ERROR    - could not open FileName
3778   STATUS_SUCCESS  - we opened the file
3779
3780 --*/
3781 {
3782   FILE  *Fptr;
3783   INT8  Line[100];
3784   INT8  Guid[100];
3785   INT8  DefineName[80];
3786
3787   Fptr = fopen (FileName, "r");
3788   if (Fptr == NULL) {
3789     Error (NULL, 0, 0, FileName, "failed to open input GUID database input file");
3790     return STATUS_ERROR;
3791   }
3792
3793   while (fgets (Line, sizeof (Line), Fptr) != NULL) {
3794     //
3795     // Get the GUID string, skip the defined name (EFI_XXX_GUID), and get the
3796     // variable name (gWhateverProtocolGuid)
3797     //
3798     if (sscanf (Line, "%s %s %*s", Guid, DefineName) == 2) {
3799       AddSymbol (DefineName, Guid, SYM_GLOBAL);
3800     }
3801   }
3802
3803   fclose (Fptr);
3804   return STATUS_SUCCESS;
3805 }
3806
3807 /*****************************************************************************
3808
3809   Returns:
3810      0 if successful standard add
3811     length of the parsed string if passed in " name = value  "
3812     < 0 on error
3813
3814 ******************************************************************************/
3815 int
3816 AddSymbol (
3817   INT8    *Name,
3818   INT8    *Value,
3819   int     Mode
3820   )
3821 {
3822   SYMBOL  *Symbol;
3823   SYMBOL  *NewSymbol;
3824   int     Len;
3825   INT8    *Start;
3826   INT8    *Cptr;
3827   INT8    CSave1;
3828   INT8    *SaveCptr1;
3829   INT8    CSave2;
3830   INT8    *SaveCptr2;
3831   INT8    ShortName[MAX_PATH];
3832
3833   Len           = 0;
3834   SaveCptr1     = NULL;
3835   CSave1        = 0;
3836   SaveCptr2     = NULL;
3837   CSave2        = 0;
3838
3839   ShortName[0]  = 0;
3840   //
3841   // Mode better be local or global symbol
3842   //
3843   if ((Mode & (SYM_LOCAL | SYM_GLOBAL | SYM_FILE)) == 0) {
3844     Error (NULL, 0, 0, "APP ERROR", "adding symbol '%s' that is not local, global, nor file level", Name);
3845     return -1;
3846   }
3847   //
3848   // If value pointer is null, then they passed us a line something like:
3849   //    varname = value, or simply var =
3850   //
3851   if (Value == NULL) {
3852     Start = Name;
3853     while (*Name && isspace (*Name)) {
3854       Name++;
3855
3856     }
3857
3858     if (!*Name) {
3859       return -1;
3860     }
3861     //
3862     // Find the end of the name. Either space or a '='.
3863     //
3864     for (Value = Name; *Value && !isspace (*Value) && (*Value != '='); Value++)
3865       ;
3866     if (!*Value) {
3867       return -1;
3868     }
3869     //
3870     // Look for the '='
3871     //
3872     Cptr = Value;
3873     while (*Value && (*Value != '=')) {
3874       Value++;
3875     }
3876
3877     if (!*Value) {
3878       return -1;
3879     }
3880
3881     //
3882     // Now truncate the name
3883     //
3884     CSave1    = *Cptr;
3885     SaveCptr1 = Cptr;
3886     *Cptr     = 0;
3887
3888     //
3889     // Skip over the = and then any spaces
3890     //
3891     Value++;
3892     while (*Value && isspace (*Value)) {
3893       Value++;
3894
3895     }
3896     //
3897     // Find end of string, checking for quoted string
3898     //
3899     if (*Value == '\"') {
3900       Value++;
3901       for (Cptr = Value; *Cptr && *Cptr != '\"'; Cptr++)
3902         ;
3903     } else {
3904       for (Cptr = Value; *Cptr && !isspace (*Cptr); Cptr++)
3905         ;
3906     }
3907     //
3908     // Null terminate the value string
3909     //
3910     if (*Cptr) {
3911       Len = (int) (Cptr - Start) + 1;
3912       CSave2    = *Cptr;
3913       SaveCptr2 = Cptr;
3914       *Cptr     = 0;
3915     } else {
3916       Len = (int) (Cptr - Start);
3917     }
3918   }
3919
3920   //
3921   // If file name or file path, and we're shortening, then print it
3922   //
3923   if ((Mode & (SYM_FILEPATH | SYM_FILENAME)) && (GetSymbolValue (SHORT_NAMES) != NULL)) {
3924     if (GetShortPathName (Value, ShortName, sizeof (ShortName)) > 0) {
3925       //
3926       // fprintf (stdout, "String value '%s' shortened to '%s'\n",
3927       //    Value, ShortName);
3928       //
3929       Value = ShortName;
3930     } else {
3931       //
3932       // fprintf (stdout, "WARNING: Failed to get short name for %s\n", Value);
3933       //
3934     }
3935   }
3936   //
3937   // We now have a symbol name and a value. Look for an existing variable of
3938   // the same type (global or local) and overwrite it.
3939   //
3940   Symbol = gGlobals.Symbol;
3941   while (Symbol) {
3942     //
3943     // Check for symbol name match
3944     //
3945     if (_stricmp (Name, Symbol->Name) == 0) {
3946       //
3947       // See if this symbol is of the same type (global or local) as what
3948       // they're requesting
3949       //
3950       if ((Symbol->Type & (SYM_LOCAL | SYM_GLOBAL)) == (Mode & (SYM_LOCAL | SYM_GLOBAL))) {
3951         //
3952         // Did they say we could overwrite it?
3953         //
3954         if (Mode & SYM_OVERWRITE) {
3955           free (Symbol->Value);
3956           Symbol->Value = (INT8 *) malloc (strlen (Value) + 1);
3957           if (Symbol->Value == NULL) {
3958             Error (NULL, 0, 0, NULL, "failed to allocate memory");
3959             return -1;
3960           }
3961
3962           strcpy (Symbol->Value, Value);
3963           //
3964           // If value == "NULL", then make it a 0-length string
3965           //
3966           if (_stricmp (Symbol->Value, "NULL") == 0) {
3967             Symbol->Value[0] = 0;
3968           }
3969
3970           return Len;
3971         } else {
3972           return STATUS_ERROR;
3973         }
3974       }
3975     }
3976
3977     Symbol = Symbol->Next;
3978   }
3979   //
3980   // Does not exist, create a new one
3981   //
3982   NewSymbol = (SYMBOL *) malloc (sizeof (SYMBOL));
3983   if (NewSymbol == NULL) {
3984     Error (NULL, 0, 0, NULL, "failed to allocate memory");
3985     return -1;
3986   }
3987
3988   memset ((INT8 *) NewSymbol, 0, sizeof (SYMBOL));
3989   NewSymbol->Name   = (INT8 *) malloc (strlen (Name) + 1);
3990   NewSymbol->Value  = (INT8 *) malloc (strlen (Value) + 1);
3991   //
3992   // Simply use the mode bits as the type.
3993   //
3994   NewSymbol->Type = Mode;
3995   if ((NewSymbol->Name == NULL) || (NewSymbol->Value == NULL)) {
3996     Error (NULL, 0, 0, NULL, "failed to allocate memory");
3997     return -1;
3998   }
3999
4000   strcpy (NewSymbol->Name, Name);
4001   strcpy (NewSymbol->Value, Value);
4002   //
4003   // Remove trailing spaces
4004   //
4005   Cptr = NewSymbol->Value + strlen (NewSymbol->Value) - 1;
4006   while (Cptr > NewSymbol->Value) {
4007     if (isspace (*Cptr)) {
4008       *Cptr = 0;
4009       Cptr--;
4010     } else {
4011       break;
4012     }
4013   }
4014   //
4015   // Add it to the head of the list.
4016   //
4017   NewSymbol->Next = gGlobals.Symbol;
4018   gGlobals.Symbol = NewSymbol;
4019   //
4020   // If value == "NULL", then make it a 0-length string
4021   //
4022   if (_stricmp (NewSymbol->Value, "NULL") == 0) {
4023     NewSymbol->Value[0] = 0;
4024   }
4025   //
4026   // Restore the terminator we inserted if they passed in var=value
4027   //
4028   if (SaveCptr1 != NULL) {
4029     *SaveCptr1 = CSave1;
4030   }
4031   if (SaveCptr2 != NULL) {
4032     *SaveCptr2 = CSave2;
4033   }
4034
4035   return Len;
4036 }
4037
4038 /*****************************************************************************
4039 ******************************************************************************/
4040 static
4041 int
4042 RemoveSymbol (
4043   INT8 *Name,
4044   INT8 SymbolType
4045   )
4046 {
4047   SYMBOL  *Symbol;
4048   SYMBOL  *PrevSymbol;
4049
4050   PrevSymbol  = NULL;
4051   Symbol      = gGlobals.Symbol;
4052   while (Symbol) {
4053     if ((_stricmp (Name, Symbol->Name) == 0) && (Symbol->Type & SymbolType)) {
4054       if (Symbol->Value) {
4055         free (Symbol->Value);
4056       }
4057
4058       free (Symbol->Name);
4059       if (PrevSymbol) {
4060         PrevSymbol->Next = Symbol->Next;
4061       } else {
4062         gGlobals.Symbol = Symbol->Next;
4063       }
4064
4065       free (Symbol);
4066       return STATUS_SUCCESS;
4067     }
4068
4069     PrevSymbol  = Symbol;
4070     Symbol      = Symbol->Next;
4071   }
4072
4073   return STATUS_WARNING;
4074 }
4075
4076 #if 0
4077
4078 /*****************************************************************************
4079 ******************************************************************************/
4080 static
4081 void
4082 FreeSections (
4083   SECTION *Sect
4084   )
4085 {
4086   SECTION *Next;
4087
4088   while (Sect != NULL) {
4089     Next = Sect->Next;
4090     if (Sect->Name != NULL) {
4091       delete[] Sect->Name;
4092     }
4093
4094     delete Sect;
4095     Sect = Next;
4096   }
4097 }
4098 #endif
4099
4100 /*****************************************************************************
4101 ******************************************************************************/
4102 static
4103 INT8 *
4104 StripLine (
4105   INT8 *Line
4106   )
4107 {
4108   INT8  *Cptr;
4109   int   Len;
4110
4111   Cptr = Line;
4112   //
4113   // Look for '#' comments in first character of line
4114   //
4115   if (*Cptr == '#') {
4116     *Cptr = 0;
4117     return Cptr;
4118   }
4119
4120   while (isspace (*Cptr)) {
4121     Cptr++;
4122   }
4123   //
4124   // Hack off newlines
4125   //
4126   Len = strlen (Cptr);
4127   if ((Len > 0) && (Cptr[Len - 1] == '\n')) {
4128     Cptr[Len - 1] = 0;
4129   }
4130   //
4131   // Hack off trailing spaces
4132   //
4133   StripTrailingSpaces (Cptr);
4134   return Cptr;
4135 }
4136
4137 /*****************************************************************************
4138   FUNCTION:  ProcessOptions()
4139
4140   DESCRIPTION: Process the command-line options.
4141 ******************************************************************************/
4142 static
4143 int
4144 ProcessOptions (
4145   int   Argc,
4146   INT8  *Argv[]
4147   )
4148 /*++
4149
4150 Routine Description:
4151
4152   Process the command line options to this utility.
4153
4154 Arguments:
4155
4156   Argc   - Standard Argc.
4157   Argv[] - Standard Argv.
4158
4159 Returns:
4160
4161 --*/
4162 {
4163   INT8  *Cptr;
4164   int   FreeCwd;
4165
4166   //
4167   // Clear out the options
4168   //
4169   memset ((INT8 *) &gGlobals, 0, sizeof (gGlobals));
4170
4171   Argc--;
4172   Argv++;
4173
4174   if (Argc == 0) {
4175     Usage ();
4176     return STATUS_ERROR;
4177   }
4178   //
4179   // Now process the arguments
4180   //
4181   while (Argc > 0) {
4182
4183     if ((Argv[0][0] == '-') || (Argv[0][0] == '/')) {
4184       switch (Argv[0][1]) {
4185       //
4186       // -? or -h help option
4187       //
4188       case '?':
4189       case 'h':
4190       case 'H':
4191         Usage ();
4192         return STATUS_ERROR;
4193
4194       //
4195       // /d symbol=name
4196       //
4197       case 'd':
4198       case 'D':
4199         //
4200         // Skip to next arg
4201         //
4202         Argc--;
4203         Argv++;
4204         if (Argc == 0) {
4205           Argv--;
4206           Error (NULL, 0, 0, NULL, "missing symbol definition with %c%c", Argv[0][0], Argv[0][1]);
4207           return STATUS_ERROR;
4208         } else {
4209           if (AddSymbol (Argv[0], NULL, SYM_OVERWRITE | SYM_GLOBAL) <= 0) {
4210             Warning (NULL, 0, 0, Argv[0], "failed to add symbol: %s");
4211           }
4212         }
4213         break;
4214
4215       //
4216       // output makefile name
4217       //
4218       case 'm':
4219       case 'M':
4220         //
4221         // Skip to next arg
4222         //
4223         Argc--;
4224         Argv++;
4225         if (Argc == 0) {
4226           Argv--;
4227           Error (NULL, 0, 0, Argv[0], "missing output makefile name with option");
4228           Usage ();
4229           return STATUS_ERROR;
4230         } else {
4231           strcpy (gGlobals.MakefileName, Argv[0]);
4232         }
4233         break;
4234
4235       //
4236       // Print a cross-reference file containing guid/basename/processor
4237       //
4238       case 'x':
4239       case 'X':
4240         //
4241         // Skip to next arg
4242         //
4243         Argc--;
4244         Argv++;
4245         if (Argc == 0) {
4246           Argv--;
4247           Error (NULL, 0, 0, Argv[0], "missing cross-reference output filename with option");
4248           Usage ();
4249           return STATUS_ERROR;
4250         } else {
4251           strcpy (gGlobals.XRefFileName, Argv[0]);
4252         }
4253         break;
4254
4255       //
4256       // GUID database file to preparse
4257       //
4258       case 'g':
4259       case 'G':
4260         //
4261         // Skip to next arg
4262         //
4263         Argc--;
4264         Argv++;
4265         if (Argc == 0) {
4266           Argv--;
4267           Error (NULL, 0, 0, Argv[0], "missing input GUID database filename with option");
4268           Usage ();
4269           return STATUS_ERROR;
4270         } else {
4271           strcpy (gGlobals.GuidDatabaseFileName, Argv[0]);
4272         }
4273         break;
4274
4275       //
4276       // Enable multi-thread build and specify the thread number
4277       //
4278       case 'n':
4279       case 'N':
4280         //
4281         // Skip to next arg
4282         //
4283         Argc--;
4284         Argv++;
4285         if (Argc == 0) {
4286           Argv--;
4287           Error (NULL, 0, 0, Argv[0], "missing input thread number with option");
4288           Usage ();
4289           return STATUS_ERROR;
4290         } else {
4291           gGlobals.ThreadNumber = atoi (Argv[0]);
4292           if (gGlobals.ThreadNumber == 0) {
4293             Argv--;
4294             Error (NULL, 0, 0, Argv[0], "input thread number should not be %s", Argv[1]);
4295             return STATUS_ERROR;
4296           } else if (gGlobals.ThreadNumber > MAXIMUM_WAIT_OBJECTS) {
4297             Argv--;
4298             Error (NULL, 0, 0, Argv[0], "input thread number should not greater than %d", MAXIMUM_WAIT_OBJECTS);
4299             return STATUS_ERROR;
4300           }
4301         }
4302         break;
4303
4304       //
4305       // Specify the multi-thread build target
4306       //
4307       case 't':
4308       case 'T':
4309         //
4310         // Skip to next arg
4311         //
4312         Argc--;
4313         Argv++;
4314         if (Argc == 0) {
4315           Argv--;
4316           Error (NULL, 0, 0, Argv[0], "missing input build target with option");
4317           Usage ();
4318           return STATUS_ERROR;
4319         } else if (_stricmp (Argv[0], "all") == 0) {
4320           gGlobals.BuildTarget |= BUILD_TARGET_ALL;
4321         } else if (_stricmp (Argv[0], "libraries") == 0) {
4322           gGlobals.BuildTarget |= BUILD_TARGET_LIBRARIES;
4323         } else if (_stricmp (Argv[0], "components") == 0) {
4324           gGlobals.BuildTarget |= BUILD_TARGET_COMPONENTS;
4325         } else {
4326           Argv--;
4327           Error (NULL, 0, 0, Argv[0], "input build target not supported");
4328           Usage ();
4329         }
4330         break;
4331
4332       case 'v':
4333       case 'V':
4334         gGlobals.Verbose = 1;
4335         break;
4336
4337       default:
4338         Error (NULL, 0, 0, Argv[0], "unrecognized option");
4339         return STATUS_ERROR;
4340       }
4341     } else {
4342       break;
4343     }
4344
4345     Argc--;
4346     Argv++;
4347   }
4348   //
4349   // Must be at least one arg left
4350   //
4351   if (Argc > 0) {
4352     gGlobals.DscFilename = Argv[0];
4353   }
4354
4355   if (gGlobals.DscFilename == NULL) {
4356     Error (NULL, 0, 0, NULL, "must specify DSC filename on command line");
4357     return STATUS_ERROR;
4358   }
4359   //
4360   // Make a global symbol for the DSC filename
4361   //
4362   AddSymbol (DSC_FILENAME, gGlobals.DscFilename, SYM_GLOBAL | SYM_FILENAME);
4363   //
4364   // If no output makefile specified, take the default
4365   //
4366   if (gGlobals.MakefileName[0] == 0) {
4367     strcpy (gGlobals.MakefileName, MAKEFILE_OUT_NAME);
4368   }
4369   //
4370   // Get the current working directory and use it for the build directory.
4371   // Only do this if they have not defined it on the command line. Do the
4372   // same for the bin dir, output dir, and library directory.
4373   //
4374   Cptr = GetSymbolValue (BUILD_DIR);
4375   if (Cptr == NULL) {
4376     Cptr    = _getcwd (NULL, 0);
4377     FreeCwd = 1;
4378     AddSymbol (BUILD_DIR, Cptr, SYM_OVERWRITE | SYM_GLOBAL | SYM_FILEPATH);
4379   } else {
4380     ReplaceSlash (Cptr);
4381     FreeCwd = 0;
4382   }
4383
4384   if (FreeCwd) {
4385     free (Cptr);
4386   }
4387
4388   //
4389   // Default build target is all
4390   //
4391   if (gGlobals.BuildTarget == 0) {
4392     gGlobals.BuildTarget = BUILD_TARGET_ALL;
4393   }
4394
4395   return 0;
4396 }
4397
4398 /*****************************************************************************
4399 ******************************************************************************/
4400 static
4401 SYMBOL *
4402 FreeSymbols (
4403   SYMBOL *Syms
4404   )
4405 {
4406   SYMBOL  *Next;
4407   while (Syms) {
4408
4409     if (Syms->Name != NULL) {
4410       free (Syms->Name);
4411     }
4412
4413     if (Syms->Value != NULL) {
4414       free (Syms->Value);
4415     }
4416
4417     Next = Syms->Next;
4418     free (Syms);
4419     Syms = Next;
4420   }
4421
4422   return Syms;
4423 }
4424
4425 /*****************************************************************************
4426 ******************************************************************************/
4427 static
4428 int
4429 GetSourceFileType (
4430   INT8 *FileName
4431   )
4432 {
4433   INT8  *Cptr;
4434   int   len;
4435   int   i;
4436
4437   len = strlen (FileName);
4438   if (len == 0) {
4439     return FILETYPE_UNKNOWN;
4440
4441   }
4442
4443   Cptr = FileName + len - 1;
4444   while ((*Cptr != '.') && (Cptr >= FileName)) {
4445     Cptr--;
4446
4447   }
4448
4449   if (*Cptr == '.') {
4450
4451     for (i = 0; mFileTypes[i].Extension != NULL; i++) {
4452       len = strlen (mFileTypes[i].Extension);
4453       if (_strnicmp (mFileTypes[i].Extension, Cptr, len) == 0) {
4454         if ((*(Cptr + len) == 0) || isspace (*(Cptr + len))) {
4455           return mFileTypes[i].FileType;
4456         }
4457       }
4458     }
4459   }
4460
4461   return FILETYPE_UNKNOWN;
4462 }
4463 //
4464 // Determine if a given file is a standard include file. If we don't know,
4465 // then assume it's not.
4466 //
4467 static
4468 int
4469 IsIncludeFile (
4470   INT8 *FileName
4471   )
4472 {
4473   INT8  *Cptr;
4474   int   len;
4475   int   i;
4476
4477   len = strlen (FileName);
4478   if (len == 0) {
4479     return 0;
4480   }
4481
4482   Cptr = FileName + len - 1;
4483   while ((*Cptr != '.') && (Cptr >= FileName)) {
4484     Cptr--;
4485   }
4486
4487   if (*Cptr == '.') {
4488     //
4489     // Now go through the list of filename extensions and try to find
4490     // a match for this file extension.
4491     //
4492     for (i = 0; mFileTypes[i].Extension != NULL; i++) {
4493       len = strlen (mFileTypes[i].Extension);
4494       if (_strnicmp (mFileTypes[i].Extension, Cptr, len) == 0) {
4495         //
4496         // Make sure that's all there is to the filename extension.
4497         //
4498         if ((*(Cptr + len) == 0) || isspace (*(Cptr + len))) {
4499           return mFileTypes[i].FileFlags & FILE_FLAG_INCLUDE;
4500         }
4501       }
4502     }
4503   }
4504
4505   return 0;
4506 }
4507
4508 /*****************************************************************************
4509 ******************************************************************************/
4510 static
4511 void
4512 StripTrailingSpaces (
4513   INT8 *Str
4514   )
4515 {
4516   INT8  *Cptr;
4517   Cptr = Str + strlen (Str) - 1;
4518   while (Cptr > Str) {
4519     if (isspace (*Cptr)) {
4520       *Cptr = 0;
4521       Cptr--;
4522     } else {
4523       break;
4524     }
4525   }
4526 }
4527
4528 /*****************************************************************************
4529 ******************************************************************************/
4530 static
4531 int
4532 GetEfiSource (
4533   VOID
4534   )
4535 {
4536   INT8  *EfiSource;
4537
4538   //
4539   // Don't set it if the user specified it on the command line.
4540   //
4541   EfiSource = GetSymbolValue (EFI_SOURCE);
4542   if ( EfiSource != NULL) {
4543     ReplaceSlash (EfiSource);
4544     if (EfiSource[strlen (EfiSource) - 1] == '\\') {
4545       EfiSource[strlen (EfiSource) - 1] = 0;
4546     }
4547     return STATUS_SUCCESS;
4548   }
4549
4550   //
4551   // Get the environmental variable setting of EFI_SOURCE.
4552   //
4553   EfiSource = getenv (EFI_SOURCE);
4554   if (EfiSource != NULL) {
4555     ReplaceSlash (EfiSource);
4556     if (EfiSource[strlen (EfiSource) - 1] == '\\') {
4557       EfiSource[strlen (EfiSource) - 1] = 0;
4558     }
4559     AddSymbol (EFI_SOURCE, EfiSource, SYM_GLOBAL | SYM_FILEPATH);
4560     return STATUS_SUCCESS;
4561   }
4562
4563   Error (NULL, 0, 0, NULL, "could not determine EFI_SOURCE");
4564   return STATUS_ERROR;
4565 }
4566
4567 void
4568 Message (
4569   UINT32  PrintMask,
4570   INT8    *Fmt,
4571   ...
4572   )
4573 {
4574   INT8    Line[MAX_LINE_LEN];
4575   va_list List;
4576
4577   va_start (List, Fmt);
4578   vsprintf (Line, Fmt, List);
4579   if (PrintMask & gGlobals.Verbose) {
4580     fprintf (stdout, "%s\n", Line);
4581   }
4582
4583   va_end (List);
4584 }
4585
4586 static
4587 void
4588 Usage (
4589   VOID
4590   )
4591 {
4592   int         Index;
4593   const char  *Str[] = {
4594     UTILITY_NAME" "UTILITY_VERSION" - Intel Process DSC File Utility",
4595     "  Copyright (C), 2004 - 2008 Intel Corporation",
4596
4597 #if ( defined(UTILITY_BUILD) && defined(UTILITY_VENDOR) )
4598     "  Built from "UTILITY_BUILD", project of "UTILITY_VENDOR,
4599 #endif
4600     "",
4601     "Usage:",
4602     "  "UTILITY_NAME" [OPTION]... DSCFILE",
4603     "Options:",
4604     "  -d var=value        to define symbol 'var' to 'value'",
4605     "  -v                  for verbose mode",
4606     "  -g filename         to preparse GUID listing file",
4607     "  -x filename         to create a cross-reference file",
4608     "  -n threadnumber     to build with multi-thread",
4609     "  -t target           to build the specified target:",
4610     "                      all, libraries or components",
4611     NULL
4612   };
4613   for (Index = 0; Str[Index] != NULL; Index++) {
4614     fprintf (stdout, "%s\n", Str[Index]);
4615   }
4616 }
4617
4618 /*++
4619
4620 Routine Description:
4621
4622   Process the [defines] section in the DSC file.
4623
4624 Arguments:
4625
4626   DscFile - pointer to the DSCFile class that contains the relevant info.
4627
4628 Returns:
4629
4630   0 if not necessarily an absolute path
4631   1 otherwise
4632
4633 --*/
4634 static
4635 int
4636 ProcessDSCDefinesSection (
4637   DSC_FILE *DscFile
4638   )
4639 {
4640   INT8    Line[MAX_LINE_LEN];
4641   INT8    Line2[MAX_EXP_LINE_LEN];
4642   INT8    *Cptr;
4643   SECTION *Sect;
4644
4645   //
4646   // Look for a [defines] section and process it
4647   //
4648   Sect = DSCFileFindSection (DscFile, DEFINES_SECTION_NAME);
4649   if (Sect == NULL) {
4650     return STATUS_ERROR;
4651   }
4652   //
4653   // Read lines while they're valid
4654   //
4655   while (DSCFileGetLine (DscFile, Line, sizeof (Line)) != NULL) {
4656     //
4657     // Expand symbols on the line
4658     //
4659     if (ExpandSymbols (Line, Line2, sizeof (Line2), 0)) {
4660       return STATUS_ERROR;
4661     }
4662     //
4663     // Strip the line
4664     //
4665     Cptr = StripLine (Line2);
4666     if (*Cptr) {
4667       //
4668       // Make the assignment
4669       //
4670       AddSymbol (Line2, NULL, SYM_OVERWRITE | SYM_GLOBAL);
4671     }
4672   }
4673
4674   return STATUS_SUCCESS;
4675 }
4676
4677 int
4678 IsAbsolutePath (
4679   char    *FileName
4680   )
4681 /*++
4682
4683 Routine Description:
4684
4685   Determine if a given filename contains the full path information.
4686
4687 Arguments:
4688
4689   FileName - the name of the file, with symbol expanded.
4690
4691 Returns:
4692
4693   0 if not necessarily an absolute path
4694   1 otherwise
4695
4696 --*/
4697 {
4698   //
4699   // If the first character is a-z, and the second character is a colon, then
4700   // it is an absolute path.
4701   //
4702   if (isalpha (FileName[0]) && (FileName[1] == ':')) {
4703     return 1;
4704   }
4705
4706   return 0;
4707 }
4708
4709 SMART_FILE *
4710 SmartOpen (
4711   char        *FileName
4712   )
4713 {
4714   SMART_FILE     *SmartFile;
4715   FILE           *Fptr;
4716   int            FileSize;
4717
4718   SmartFile = malloc (sizeof (SMART_FILE));
4719   if (SmartFile == NULL) {
4720     return NULL;
4721   }
4722   memset (SmartFile, 0, sizeof (SMART_FILE));
4723
4724   SmartFile->FileName = malloc (strlen (FileName) + 1);
4725   if (SmartFile->FileName == NULL){
4726     SmartFree (SmartFile);
4727     return NULL;
4728   }
4729   strcpy (SmartFile->FileName, FileName);
4730
4731   if ((Fptr = fopen (FileName, "r")) != NULL) {
4732     fseek (Fptr, 0, SEEK_END);
4733     FileSize = ftell (Fptr);
4734     fseek (Fptr, 0, SEEK_SET);
4735     SmartFile->FileContent = malloc (FileSize + 1);
4736     if (SmartFile->FileContent != NULL) {
4737       memset (SmartFile->FileContent, 0, FileSize + 1);
4738       //
4739       // Usually FileLength < FileSize, because in text mode, carriage return-linefeed
4740       // combinations are translated into single linefeeds on input
4741       //
4742       SmartFile->FileLength = fread (SmartFile->FileContent, sizeof(char), FileSize, Fptr);
4743     }
4744     fclose (Fptr);
4745   }
4746
4747   //
4748   // No previous output file content, re-create the file
4749   //
4750   if (SmartFile->FileContent == NULL) {
4751     if ((SmartFile->FilePtr = fopen (FileName, "w")) == NULL) {
4752       SmartFree (SmartFile);
4753       return NULL;
4754     }
4755   }
4756
4757   return SmartFile;
4758 }
4759
4760 int
4761 SmartWrite (
4762   SMART_FILE  *SmartFile,
4763   char        *String
4764   )
4765 {
4766   int  StrLen;
4767
4768   if (SmartFile->FilePtr != NULL) {
4769     return fprintf (SmartFile->FilePtr, "%s", String);
4770   } else {
4771     StrLen = strlen (String);
4772     if ((StrLen > SmartFile->FileLength - SmartFile->FilePosition) ||
4773        (_strnicmp (&SmartFile->FileContent[SmartFile->FilePosition], String, StrLen) != 0)) {
4774       //
4775       // file changed, need to re-create.
4776       //
4777       if ((SmartFile->FilePtr = fopen (SmartFile->FileName, "w")) == NULL) {
4778         Error (NULL, 0, 0, SmartFile->FileName, "could not open file for writing when SmartWrite");
4779         return -1;
4780       } else {
4781         SmartFile->FileContent[SmartFile->FilePosition] = 0;
4782         fprintf (SmartFile->FilePtr, "%s%s", SmartFile->FileContent, String);
4783         return StrLen;
4784       }
4785     } else {
4786       SmartFile->FilePosition += StrLen;
4787       return StrLen;
4788     }
4789   }
4790 }
4791
4792 void
4793 SmartClose (
4794   SMART_FILE  *SmartFile
4795   )
4796 {
4797   if ((SmartFile->FilePtr == NULL) && (SmartFile->FilePosition < SmartFile->FileLength)) {
4798     //
4799     // The new file is smaller than before, re-create it.
4800     //
4801     if ((SmartFile->FilePtr = fopen (SmartFile->FileName, "w")) == NULL) {
4802       Error (NULL, 0, 0, SmartFile->FileName, "could not open file for writing when SmartClose");
4803     } else {
4804       SmartFile->FileContent[SmartFile->FilePosition] = 0;
4805       fprintf (SmartFile->FilePtr, "%s", SmartFile->FileContent);
4806     }
4807   }
4808
4809   SmartFree(SmartFile);
4810 }
4811
4812 static
4813 void
4814 SmartFree (
4815   SMART_FILE  *SmartFile
4816   )
4817 {
4818   if (SmartFile == NULL) {
4819     return;
4820   }
4821
4822   if (SmartFile->FileName != NULL ) {
4823     free (SmartFile->FileName);
4824   }
4825
4826   if (SmartFile->FileContent != NULL ) {
4827     free (SmartFile->FileContent);
4828   }
4829
4830   if (SmartFile->FilePtr != NULL ) {
4831     fclose (SmartFile->FilePtr);
4832   }
4833
4834   free (SmartFile);
4835
4836   return;
4837 }
4838
4839 static
4840 int
4841 AddModuleName (
4842   SYMBOL  **SymbolList,
4843   INT8    *ModuleName,
4844   INT8    *InfName
4845   )
4846 /*++
4847
4848 Routine Description:
4849
4850   Add module name in the global module list.
4851   For the same module names, it is only added once.
4852
4853 Arguments:
4854   SymbolList : add name into this list
4855   ModuleName : point to one module name char string.
4856   InfName    : point to this module inf file name with path.
4857
4858 Returns:
4859
4860   0 : Successfully add input name into the global list.
4861   other value : allocate memory failed.
4862
4863 --*/
4864 {
4865   SYMBOL *CurrentSymbol;
4866   SYMBOL *LastSymbol;
4867
4868   //
4869   // Get the global module list.
4870   //
4871   CurrentSymbol = *SymbolList;
4872   LastSymbol    = *SymbolList;
4873
4874   //
4875   // Search whether this module name has been added into the global list.
4876   //
4877   while (CurrentSymbol != NULL) {
4878     if (_stricmp (CurrentSymbol->Name, ModuleName) == 0) {
4879       if ((CurrentSymbol->Value == NULL) && (InfName == NULL)) {
4880         break;
4881       } else if ((CurrentSymbol->Value != NULL) && (InfName != NULL) && \
4882         (_stricmp (CurrentSymbol->Value, InfName) == 0)) {
4883         break;
4884       }
4885     }
4886     LastSymbol    = CurrentSymbol;
4887     CurrentSymbol = CurrentSymbol->Next;
4888   }
4889
4890   //
4891   // Add new module name in list.
4892   //
4893   if (CurrentSymbol == NULL) {
4894     CurrentSymbol = (SYMBOL *) malloc (sizeof (SYMBOL));
4895     if (CurrentSymbol == NULL) {
4896       Error (NULL, 0, 0, NULL, "failed to allocate memory");
4897       return -1;
4898     }
4899     memset ((INT8 *) CurrentSymbol, 0, sizeof (SYMBOL));
4900
4901     if (ModuleName != NULL) {
4902       CurrentSymbol->Name   = (INT8 *) malloc (strlen (ModuleName) + 1);
4903       strcpy (CurrentSymbol->Name, ModuleName);
4904     }
4905
4906     if (InfName != NULL) {
4907       CurrentSymbol->Value  = (INT8 *) malloc (strlen (InfName) + 1);
4908       strcpy (CurrentSymbol->Value, InfName);
4909     }
4910
4911     if (LastSymbol == NULL) {
4912       *SymbolList      = CurrentSymbol;
4913     } else {
4914       LastSymbol->Next = CurrentSymbol;
4915     }
4916   }
4917
4918   return 0;
4919 }
4920
4921
4922 static
4923 void
4924 ReplaceSlash (
4925   INT8    *Path
4926   )
4927 /*++
4928
4929 Routine Description:
4930
4931   Replace '/' with '\\'
4932
4933 Returns:
4934
4935 --*/
4936 {
4937   while (*Path) {
4938     if (*Path == '/') {
4939       *Path = '\\';
4940     }
4941     Path++;
4942   }
4943 }