BaseTools/Source/Python/AutoGen/GenMake.py

   1 ## @file
   2 # Create makefile for MS nmake and GNU make
   3 #
   4 # Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>
   5 # This program and the accompanying materials
   6 # are licensed and made available under the terms and conditions of the BSD License
   7 # which accompanies this distribution.  The full text of the license may be found at
   8 # http://opensource.org/licenses/bsd-license.php
   9 #
  10 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12 #
  13
  14 ## Import Modules
  15 #
  16 import Common.LongFilePathOs as os
  17 import sys
  18 import string
  19 import re
  20 import os.path as path
  21 from Common.LongFilePathSupport import OpenLongFilePath as open
  22 from Common.MultipleWorkspace import MultipleWorkspace as mws
  23 from Common.BuildToolError import *
  24 from Common.Misc import *
  25 from Common.String import *
  26 from BuildEngine import *
  27 import Common.GlobalData as GlobalData
  28 from collections import OrderedDict
  29
  30 ## Regular expression for finding header file inclusions
  31 gIncludePattern = re.compile(r"^[ \t]*#?[ \t]*include(?:[ \t]*(?:\\(?:\r\n|\r|\n))*[ \t]*)*(?:\(?[\"<]?[ \t]*)([-\w.\\/() \t]+)(?:[ \t]*[\">]?\)?)", re.MULTILINE | re.UNICODE | re.IGNORECASE)
  32
  33 ## Regular expression for matching macro used in header file inclusion
  34 gMacroPattern = re.compile("([_A-Z][_A-Z0-9]*)[ \t]*\((.+)\)", re.UNICODE)
  35
  36 gIsFileMap = {}
  37
  38 ## pattern for include style in Edk.x code
  39 gProtocolDefinition = "Protocol/%(HeaderKey)s/%(HeaderKey)s.h"
  40 gGuidDefinition = "Guid/%(HeaderKey)s/%(HeaderKey)s.h"
  41 gArchProtocolDefinition = "ArchProtocol/%(HeaderKey)s/%(HeaderKey)s.h"
  42 gPpiDefinition = "Ppi/%(HeaderKey)s/%(HeaderKey)s.h"
  43 gIncludeMacroConversion = {
  44   "EFI_PROTOCOL_DEFINITION"         :   gProtocolDefinition,
  45   "EFI_GUID_DEFINITION"             :   gGuidDefinition,
  46   "EFI_ARCH_PROTOCOL_DEFINITION"    :   gArchProtocolDefinition,
  47   "EFI_PROTOCOL_PRODUCER"           :   gProtocolDefinition,
  48   "EFI_PROTOCOL_CONSUMER"           :   gProtocolDefinition,
  49   "EFI_PROTOCOL_DEPENDENCY"         :   gProtocolDefinition,
  50   "EFI_ARCH_PROTOCOL_PRODUCER"      :   gArchProtocolDefinition,
  51   "EFI_ARCH_PROTOCOL_CONSUMER"      :   gArchProtocolDefinition,
  52   "EFI_ARCH_PROTOCOL_DEPENDENCY"    :   gArchProtocolDefinition,
  53   "EFI_PPI_DEFINITION"              :   gPpiDefinition,
  54   "EFI_PPI_PRODUCER"                :   gPpiDefinition,
  55   "EFI_PPI_CONSUMER"                :   gPpiDefinition,
  56   "EFI_PPI_DEPENDENCY"              :   gPpiDefinition,
  57 }
  58
  59 ## default makefile type
  60 gMakeType = ""
  61 if sys.platform == "win32":
  62     gMakeType = "nmake"
  63 else:
  64     gMakeType = "gmake"
  65
  66
  67 ## BuildFile class
  68 #
  69 #  This base class encapsules build file and its generation. It uses template to generate
  70 #  the content of build file. The content of build file will be got from AutoGen objects.
  71 #
  72 class BuildFile(object):
  73     ## template used to generate the build file (i.e. makefile if using make)
  74     _TEMPLATE_ = TemplateString('')
  75
  76     _DEFAULT_FILE_NAME_ = "Makefile"
  77
  78     ## default file name for each type of build file
  79     _FILE_NAME_ = {
  80         "nmake" :   "Makefile",
  81         "gmake" :   "GNUmakefile"
  82     }
  83
  84     ## Fixed header string for makefile
  85     _MAKEFILE_HEADER = '''#
  86 # DO NOT EDIT
  87 # This file is auto-generated by build utility
  88 #
  89 # Module Name:
  90 #
  91 #   %s
  92 #
  93 # Abstract:
  94 #
  95 #   Auto-generated makefile for building modules, libraries or platform
  96 #
  97     '''
  98
  99     ## Header string for each type of build file
 100     _FILE_HEADER_ = {
 101         "nmake" :   _MAKEFILE_HEADER % _FILE_NAME_["nmake"],
 102         "gmake" :   _MAKEFILE_HEADER % _FILE_NAME_["gmake"]
 103     }
 104
 105     ## shell commands which can be used in build file in the form of macro
 106     #   $(CP)     copy file command
 107     #   $(MV)     move file command
 108     #   $(RM)     remove file command
 109     #   $(MD)     create dir command
 110     #   $(RD)     remove dir command
 111     #
 112     _SHELL_CMD_ = {
 113         "nmake" : {
 114             "CP"    :   "copy /y",
 115             "MV"    :   "move /y",
 116             "RM"    :   "del /f /q",
 117             "MD"    :   "mkdir",
 118             "RD"    :   "rmdir /s /q",
 119         },
 120
 121         "gmake" : {
 122             "CP"    :   "cp -f",
 123             "MV"    :   "mv -f",
 124             "RM"    :   "rm -f",
 125             "MD"    :   "mkdir -p",
 126             "RD"    :   "rm -r -f",
 127         }
 128     }
 129
 130     ## directory separator
 131     _SEP_ = {
 132         "nmake" :   "\\",
 133         "gmake" :   "/"
 134     }
 135
 136     ## directory creation template
 137     _MD_TEMPLATE_ = {
 138         "nmake" :   'if not exist %(dir)s $(MD) %(dir)s',
 139         "gmake" :   "$(MD) %(dir)s"
 140     }
 141
 142     ## directory removal template
 143     _RD_TEMPLATE_ = {
 144         "nmake" :   'if exist %(dir)s $(RD) %(dir)s',
 145         "gmake" :   "$(RD) %(dir)s"
 146     }
 147     ## cp if exist
 148     _CP_TEMPLATE_ = {
 149         "nmake" :   'if exist %(Src)s $(CP) %(Src)s %(Dst)s',
 150         "gmake" :   "test -f %(Src)s && $(CP) %(Src)s %(Dst)s"
 151     }
 152
 153     _CD_TEMPLATE_ = {
 154         "nmake" :   'if exist %(dir)s cd %(dir)s',
 155         "gmake" :   "test -e %(dir)s && cd %(dir)s"
 156     }
 157
 158     _MAKE_TEMPLATE_ = {
 159         "nmake" :   'if exist %(file)s "$(MAKE)" $(MAKE_FLAGS) -f %(file)s',
 160         "gmake" :   'test -e %(file)s && "$(MAKE)" $(MAKE_FLAGS) -f %(file)s'
 161     }
 162
 163     _INCLUDE_CMD_ = {
 164         "nmake" :   '!INCLUDE',
 165         "gmake" :   "include"
 166     }
 167
 168     _INC_FLAG_ = {"MSFT" : "/I", "GCC" : "-I", "INTEL" : "-I", "RVCT" : "-I"}
 169
 170     ## Constructor of BuildFile
 171     #
 172     #   @param  AutoGenObject   Object of AutoGen class
 173     #
 174     def __init__(self, AutoGenObject):
 175         self._AutoGenObject = AutoGenObject
 176         self._FileType = gMakeType
 177
 178     ## Create build file
 179     #
 180     #   @param  FileType    Type of build file. Only nmake and gmake are supported now.
 181     #
 182     #   @retval TRUE        The build file is created or re-created successfully
 183     #   @retval FALSE       The build file exists and is the same as the one to be generated
 184     #
 185     def Generate(self, FileType=gMakeType):
 186         if FileType not in self._FILE_NAME_:
 187             EdkLogger.error("build", PARAMETER_INVALID, "Invalid build type [%s]" % FileType,
 188                             ExtraData="[%s]" % str(self._AutoGenObject))
 189         self._FileType = FileType
 190         FileContent = self._TEMPLATE_.Replace(self._TemplateDict)
 191         FileName = self._FILE_NAME_[FileType]
 192         return SaveFileOnChange(os.path.join(self._AutoGenObject.MakeFileDir, FileName), FileContent, False)
 193
 194     ## Return a list of directory creation command string
 195     #
 196     #   @param      DirList     The list of directory to be created
 197     #
 198     #   @retval     list        The directory creation command list
 199     #
 200     def GetCreateDirectoryCommand(self, DirList):
 201         return [self._MD_TEMPLATE_[self._FileType] % {'dir':Dir} for Dir in DirList]
 202
 203     ## Return a list of directory removal command string
 204     #
 205     #   @param      DirList     The list of directory to be removed
 206     #
 207     #   @retval     list        The directory removal command list
 208     #
 209     def GetRemoveDirectoryCommand(self, DirList):
 210         return [self._RD_TEMPLATE_[self._FileType] % {'dir':Dir} for Dir in DirList]
 211
 212     def PlaceMacro(self, Path, MacroDefinitions={}):
 213         if Path.startswith("$("):
 214             return Path
 215         else:
 216             PathLength = len(Path)
 217             for MacroName in MacroDefinitions:
 218                 MacroValue = MacroDefinitions[MacroName]
 219                 MacroValueLength = len(MacroValue)
 220                 if MacroValueLength == 0:
 221                     continue
 222                 if MacroValueLength <= PathLength and Path.startswith(MacroValue):
 223                     Path = "$(%s)%s" % (MacroName, Path[MacroValueLength:])
 224                     break
 225             return Path
 226
 227 ## ModuleMakefile class
 228 #
 229 #  This class encapsules makefie and its generation for module. It uses template to generate
 230 #  the content of makefile. The content of makefile will be got from ModuleAutoGen object.
 231 #
 232 class ModuleMakefile(BuildFile):
 233     ## template used to generate the makefile for module
 234     _TEMPLATE_ = TemplateString('''\
 235 ${makefile_header}
 236
 237 #
 238 # Platform Macro Definition
 239 #
 240 PLATFORM_NAME = ${platform_name}
 241 PLATFORM_GUID = ${platform_guid}
 242 PLATFORM_VERSION = ${platform_version}
 243 PLATFORM_RELATIVE_DIR = ${platform_relative_directory}
 244 PLATFORM_DIR = ${platform_dir}
 245 PLATFORM_OUTPUT_DIR = ${platform_output_directory}
 246
 247 #
 248 # Module Macro Definition
 249 #
 250 MODULE_NAME = ${module_name}
 251 MODULE_GUID = ${module_guid}
 252 MODULE_NAME_GUID = ${module_name_guid}
 253 MODULE_VERSION = ${module_version}
 254 MODULE_TYPE = ${module_type}
 255 MODULE_FILE = ${module_file}
 256 MODULE_FILE_BASE_NAME = ${module_file_base_name}
 257 BASE_NAME = $(MODULE_NAME)
 258 MODULE_RELATIVE_DIR = ${module_relative_directory}
 259 PACKAGE_RELATIVE_DIR = ${package_relative_directory}
 260 MODULE_DIR = ${module_dir}
 261 FFS_OUTPUT_DIR = ${ffs_output_directory}
 262
 263 MODULE_ENTRY_POINT = ${module_entry_point}
 264 ARCH_ENTRY_POINT = ${arch_entry_point}
 265 IMAGE_ENTRY_POINT = ${image_entry_point}
 266
 267 ${BEGIN}${module_extra_defines}
 268 ${END}
 269 #
 270 # Build Configuration Macro Definition
 271 #
 272 ARCH = ${architecture}
 273 TOOLCHAIN = ${toolchain_tag}
 274 TOOLCHAIN_TAG = ${toolchain_tag}
 275 TARGET = ${build_target}
 276
 277 #
 278 # Build Directory Macro Definition
 279 #
 280 # PLATFORM_BUILD_DIR = ${platform_build_directory}
 281 BUILD_DIR = ${platform_build_directory}
 282 BIN_DIR = $(BUILD_DIR)${separator}${architecture}
 283 LIB_DIR = $(BIN_DIR)
 284 MODULE_BUILD_DIR = ${module_build_directory}
 285 OUTPUT_DIR = ${module_output_directory}
 286 DEBUG_DIR = ${module_debug_directory}
 287 DEST_DIR_OUTPUT = $(OUTPUT_DIR)
 288 DEST_DIR_DEBUG = $(DEBUG_DIR)
 289
 290 #
 291 # Shell Command Macro
 292 #
 293 ${BEGIN}${shell_command_code} = ${shell_command}
 294 ${END}
 295
 296 #
 297 # Tools definitions specific to this module
 298 #
 299 ${BEGIN}${module_tool_definitions}
 300 ${END}
 301 MAKE_FILE = ${makefile_path}
 302
 303 #
 304 # Build Macro
 305 #
 306 ${BEGIN}${file_macro}
 307 ${END}
 308
 309 COMMON_DEPS = ${BEGIN}${common_dependency_file} \\
 310               ${END}
 311
 312 #
 313 # Overridable Target Macro Definitions
 314 #
 315 FORCE_REBUILD = force_build
 316 INIT_TARGET = init
 317 PCH_TARGET =
 318 BC_TARGET = ${BEGIN}${backward_compatible_target} ${END}
 319 CODA_TARGET = ${BEGIN}${remaining_build_target} \\
 320               ${END}
 321
 322 #
 323 # Default target, which will build dependent libraries in addition to source files
 324 #
 325
 326 all: mbuild
 327
 328
 329 #
 330 # Target used when called from platform makefile, which will bypass the build of dependent libraries
 331 #
 332
 333 pbuild: $(INIT_TARGET) $(BC_TARGET) $(PCH_TARGET) $(CODA_TARGET)
 334
 335 #
 336 # ModuleTarget
 337 #
 338
 339 mbuild: $(INIT_TARGET) $(BC_TARGET) gen_libs $(PCH_TARGET) $(CODA_TARGET)
 340
 341 #
 342 # Build Target used in multi-thread build mode, which will bypass the init and gen_libs targets
 343 #
 344
 345 tbuild: $(BC_TARGET) $(PCH_TARGET) $(CODA_TARGET)
 346
 347 #
 348 # Phony target which is used to force executing commands for a target
 349 #
 350 force_build:
 351 \t-@
 352
 353 #
 354 # Target to update the FD
 355 #
 356
 357 fds: mbuild gen_fds
 358
 359 #
 360 # Initialization target: print build information and create necessary directories
 361 #
 362 init: info dirs
 363
 364 info:
 365 \t-@echo Building ... $(MODULE_DIR)${separator}$(MODULE_FILE) [$(ARCH)]
 366
 367 dirs:
 368 ${BEGIN}\t-@${create_directory_command}\n${END}
 369
 370 strdefs:
 371 \t-@$(CP) $(DEBUG_DIR)${separator}AutoGen.h $(DEBUG_DIR)${separator}$(MODULE_NAME)StrDefs.h
 372
 373 #
 374 # GenLibsTarget
 375 #
 376 gen_libs:
 377 \t${BEGIN}@"$(MAKE)" $(MAKE_FLAGS) -f ${dependent_library_build_directory}${separator}${makefile_name}
 378 \t${END}@cd $(MODULE_BUILD_DIR)
 379
 380 #
 381 # Build Flash Device Image
 382 #
 383 gen_fds:
 384 \t@"$(MAKE)" $(MAKE_FLAGS) -f $(BUILD_DIR)${separator}${makefile_name} fds
 385 \t@cd $(MODULE_BUILD_DIR)
 386
 387 #
 388 # Individual Object Build Targets
 389 #
 390 ${BEGIN}${file_build_target}
 391 ${END}
 392
 393 #
 394 # clean all intermediate files
 395 #
 396 clean:
 397 \t${BEGIN}${clean_command}
 398 \t${END}\t$(RM) AutoGenTimeStamp
 399
 400 #
 401 # clean all generated files
 402 #
 403 cleanall:
 404 ${BEGIN}\t${cleanall_command}
 405 ${END}\t$(RM) *.pdb *.idb > NUL 2>&1
 406 \t$(RM) $(BIN_DIR)${separator}$(MODULE_NAME).efi
 407 \t$(RM) AutoGenTimeStamp
 408
 409 #
 410 # clean all dependent libraries built
 411 #
 412 cleanlib:
 413 \t${BEGIN}-@${library_build_command} cleanall
 414 \t${END}@cd $(MODULE_BUILD_DIR)\n\n''')
 415
 416     _FILE_MACRO_TEMPLATE = TemplateString("${macro_name} = ${BEGIN} \\\n    ${source_file}${END}\n")
 417     _BUILD_TARGET_TEMPLATE = TemplateString("${BEGIN}${target} : ${deps}\n${END}\t${cmd}\n")
 418
 419     ## Constructor of ModuleMakefile
 420     #
 421     #   @param  ModuleAutoGen   Object of ModuleAutoGen class
 422     #
 423     def __init__(self, ModuleAutoGen):
 424         BuildFile.__init__(self, ModuleAutoGen)
 425         self.PlatformInfo = self._AutoGenObject.PlatformInfo
 426
 427         self.ResultFileList = []
 428         self.IntermediateDirectoryList = ["$(DEBUG_DIR)", "$(OUTPUT_DIR)"]
 429
 430         self.SourceFileDatabase = {}        # {file type : file path}
 431         self.DestFileDatabase = {}          # {file type : file path}
 432         self.FileBuildTargetList = []       # [(src, target string)]
 433         self.BuildTargetList = []           # [target string]
 434         self.PendingBuildTargetList = []    # [FileBuildRule objects]
 435         self.CommonFileDependency = []
 436         self.FileListMacros = {}
 437         self.ListFileMacros = {}
 438
 439         self.FileCache = {}
 440         self.FileDependency = []
 441         self.LibraryBuildCommandList = []
 442         self.LibraryFileList = []
 443         self.LibraryMakefileList = []
 444         self.LibraryBuildDirectoryList = []
 445         self.SystemLibraryList = []
 446         self.Macros = OrderedDict()
 447         self.Macros["OUTPUT_DIR"      ] = self._AutoGenObject.Macros["OUTPUT_DIR"]
 448         self.Macros["DEBUG_DIR"       ] = self._AutoGenObject.Macros["DEBUG_DIR"]
 449         self.Macros["MODULE_BUILD_DIR"] = self._AutoGenObject.Macros["MODULE_BUILD_DIR"]
 450         self.Macros["BIN_DIR"         ] = self._AutoGenObject.Macros["BIN_DIR"]
 451         self.Macros["BUILD_DIR"       ] = self._AutoGenObject.Macros["BUILD_DIR"]
 452         self.Macros["WORKSPACE"       ] = self._AutoGenObject.Macros["WORKSPACE"]
 453         self.Macros["FFS_OUTPUT_DIR"  ] = self._AutoGenObject.Macros["FFS_OUTPUT_DIR"]
 454         self.GenFfsList                 = ModuleAutoGen.GenFfsList
 455         self.MacroList = ['FFS_OUTPUT_DIR', 'MODULE_GUID', 'OUTPUT_DIR']
 456         self.FfsOutputFileList = []
 457
 458     # Compose a dict object containing information used to do replacement in template
 459     def _CreateTemplateDict(self):
 460         if self._FileType not in self._SEP_:
 461             EdkLogger.error("build", PARAMETER_INVALID, "Invalid Makefile type [%s]" % self._FileType,
 462                             ExtraData="[%s]" % str(self._AutoGenObject))
 463         Separator = self._SEP_[self._FileType]
 464
 465         # break build if no source files and binary files are found
 466         if len(self._AutoGenObject.SourceFileList) == 0 and len(self._AutoGenObject.BinaryFileList) == 0:
 467             EdkLogger.error("build", AUTOGEN_ERROR, "No files to be built in module [%s, %s, %s]"
 468                             % (self._AutoGenObject.BuildTarget, self._AutoGenObject.ToolChain, self._AutoGenObject.Arch),
 469                             ExtraData="[%s]" % str(self._AutoGenObject))
 470
 471         # convert dependent libraries to build command
 472         self.ProcessDependentLibrary()
 473         if len(self._AutoGenObject.Module.ModuleEntryPointList) > 0:
 474             ModuleEntryPoint = self._AutoGenObject.Module.ModuleEntryPointList[0]
 475         else:
 476             ModuleEntryPoint = "_ModuleEntryPoint"
 477
 478         # Intel EBC compiler enforces EfiMain
 479         if self._AutoGenObject.AutoGenVersion < 0x00010005 and self._AutoGenObject.Arch == "EBC":
 480             ArchEntryPoint = "EfiMain"
 481         else:
 482             ArchEntryPoint = ModuleEntryPoint
 483
 484         if self._AutoGenObject.Arch == "EBC":
 485             # EBC compiler always use "EfiStart" as entry point. Only applies to EdkII modules
 486             ImageEntryPoint = "EfiStart"
 487         elif self._AutoGenObject.AutoGenVersion < 0x00010005:
 488             # Edk modules use entry point specified in INF file
 489             ImageEntryPoint = ModuleEntryPoint
 490         else:
 491             # EdkII modules always use "_ModuleEntryPoint" as entry point
 492             ImageEntryPoint = "_ModuleEntryPoint"
 493
 494         for k, v in self._AutoGenObject.Module.Defines.iteritems():
 495             if k not in self._AutoGenObject.Macros:
 496                 self._AutoGenObject.Macros[k] = v
 497
 498         if 'MODULE_ENTRY_POINT' not in self._AutoGenObject.Macros.keys():
 499             self._AutoGenObject.Macros['MODULE_ENTRY_POINT'] = ModuleEntryPoint
 500         if 'ARCH_ENTRY_POINT' not in self._AutoGenObject.Macros.keys():
 501             self._AutoGenObject.Macros['ARCH_ENTRY_POINT'] = ArchEntryPoint
 502         if 'IMAGE_ENTRY_POINT' not in self._AutoGenObject.Macros.keys():
 503             self._AutoGenObject.Macros['IMAGE_ENTRY_POINT'] = ImageEntryPoint
 504
 505         PCI_COMPRESS_Flag = False
 506         for k, v in self._AutoGenObject.Module.Defines.iteritems():
 507             if 'PCI_COMPRESS' == k and 'TRUE' == v:
 508                 PCI_COMPRESS_Flag = True
 509
 510         # tools definitions
 511         ToolsDef = []
 512         IncPrefix = self._INC_FLAG_[self._AutoGenObject.ToolChainFamily]
 513         for Tool in self._AutoGenObject.BuildOption:
 514             for Attr in self._AutoGenObject.BuildOption[Tool]:
 515                 Value = self._AutoGenObject.BuildOption[Tool][Attr]
 516                 if Attr == "FAMILY":
 517                     continue
 518                 elif Attr == "PATH":
 519                     ToolsDef.append("%s = %s" % (Tool, Value))
 520                 else:
 521                     # Don't generate MAKE_FLAGS in makefile. It's put in environment variable.
 522                     if Tool == "MAKE":
 523                         continue
 524                     # Remove duplicated include path, if any
 525                     if Attr == "FLAGS":
 526                         Value = RemoveDupOption(Value, IncPrefix, self._AutoGenObject.IncludePathList)
 527                         if Tool == "OPTROM" and PCI_COMPRESS_Flag:
 528                             ValueList = Value.split()
 529                             if ValueList:
 530                                 for i, v in enumerate(ValueList):
 531                                     if '-e' == v:
 532                                         ValueList[i] = '-ec'
 533                                 Value = ' '.join(ValueList)
 534
 535                     ToolsDef.append("%s_%s = %s" % (Tool, Attr, Value))
 536             ToolsDef.append("")
 537
 538         # generate the Response file and Response flag
 539         RespDict = self.CommandExceedLimit()
 540         RespFileList = os.path.join(self._AutoGenObject.OutputDir, 'respfilelist.txt')
 541         if RespDict:
 542             RespFileListContent = ''
 543             for Resp in RespDict.keys():
 544                 RespFile = os.path.join(self._AutoGenObject.OutputDir, str(Resp).lower() + '.txt')
 545                 StrList = RespDict[Resp].split(' ')
 546                 UnexpandMacro = []
 547                 NewStr = []
 548                 for Str in StrList:
 549                     if '$' in Str:
 550                         UnexpandMacro.append(Str)
 551                     else:
 552                         NewStr.append(Str)
 553                 UnexpandMacroStr = ' '.join(UnexpandMacro)
 554                 NewRespStr = ' '.join(NewStr)
 555                 SaveFileOnChange(RespFile, NewRespStr, False)
 556                 ToolsDef.append("%s = %s" % (Resp, UnexpandMacroStr + ' @' + RespFile))
 557                 RespFileListContent += '@' + RespFile + os.linesep
 558                 RespFileListContent += NewRespStr + os.linesep
 559             SaveFileOnChange(RespFileList, RespFileListContent, False)
 560         else:
 561             if os.path.exists(RespFileList):
 562                 os.remove(RespFileList)
 563
 564         # convert source files and binary files to build targets
 565         self.ResultFileList = [str(T.Target) for T in self._AutoGenObject.CodaTargetList]
 566         if len(self.ResultFileList) == 0 and len(self._AutoGenObject.SourceFileList) <> 0:
 567             EdkLogger.error("build", AUTOGEN_ERROR, "Nothing to build",
 568                             ExtraData="[%s]" % str(self._AutoGenObject))
 569
 570         self.ProcessBuildTargetList()
 571         self.ParserGenerateFfsCmd()
 572
 573         # Generate macros used to represent input files
 574         FileMacroList = [] # macro name = file list
 575         for FileListMacro in self.FileListMacros:
 576             FileMacro = self._FILE_MACRO_TEMPLATE.Replace(
 577                                                     {
 578                                                         "macro_name"  : FileListMacro,
 579                                                         "source_file" : self.FileListMacros[FileListMacro]
 580                                                     }
 581                                                     )
 582             FileMacroList.append(FileMacro)
 583
 584         # INC_LIST is special
 585         FileMacro = ""
 586         IncludePathList = []
 587         for P in  self._AutoGenObject.IncludePathList:
 588             IncludePathList.append(IncPrefix + self.PlaceMacro(P, self.Macros))
 589             if FileBuildRule.INC_LIST_MACRO in self.ListFileMacros:
 590                 self.ListFileMacros[FileBuildRule.INC_LIST_MACRO].append(IncPrefix + P)
 591         FileMacro += self._FILE_MACRO_TEMPLATE.Replace(
 592                                                 {
 593                                                     "macro_name"   : "INC",
 594                                                     "source_file" : IncludePathList
 595                                                 }
 596                                                 )
 597         FileMacroList.append(FileMacro)
 598
 599         # Generate macros used to represent files containing list of input files
 600         for ListFileMacro in self.ListFileMacros:
 601             ListFileName = os.path.join(self._AutoGenObject.OutputDir, "%s.lst" % ListFileMacro.lower()[:len(ListFileMacro) - 5])
 602             FileMacroList.append("%s = %s" % (ListFileMacro, ListFileName))
 603             SaveFileOnChange(
 604                 ListFileName,
 605                 "\n".join(self.ListFileMacros[ListFileMacro]),
 606                 False
 607                 )
 608
 609         # Edk modules need <BaseName>StrDefs.h for string ID
 610         #if self._AutoGenObject.AutoGenVersion < 0x00010005 and len(self._AutoGenObject.UnicodeFileList) > 0:
 611         #    BcTargetList = ['strdefs']
 612         #else:
 613         #    BcTargetList = []
 614         BcTargetList = []
 615
 616         MakefileName = self._FILE_NAME_[self._FileType]
 617         LibraryMakeCommandList = []
 618         for D in self.LibraryBuildDirectoryList:
 619             Command = self._MAKE_TEMPLATE_[self._FileType] % {"file":os.path.join(D, MakefileName)}
 620             LibraryMakeCommandList.append(Command)
 621
 622         package_rel_dir = self._AutoGenObject.SourceDir
 623         current_dir = self.Macros["WORKSPACE"]
 624         found = False
 625         while not found and os.sep in package_rel_dir:
 626             index = package_rel_dir.index(os.sep)
 627             current_dir = mws.join(current_dir, package_rel_dir[:index])
 628             if os.path.exists(current_dir):
 629                 for fl in os.listdir(current_dir):
 630                     if fl.endswith('.dec'):
 631                         found = True
 632                         break
 633             package_rel_dir = package_rel_dir[index + 1:]
 634
 635         MakefileTemplateDict = {
 636             "makefile_header"           : self._FILE_HEADER_[self._FileType],
 637             "makefile_path"             : os.path.join("$(MODULE_BUILD_DIR)", MakefileName),
 638             "makefile_name"             : MakefileName,
 639             "platform_name"             : self.PlatformInfo.Name,
 640             "platform_guid"             : self.PlatformInfo.Guid,
 641             "platform_version"          : self.PlatformInfo.Version,
 642             "platform_relative_directory": self.PlatformInfo.SourceDir,
 643             "platform_output_directory" : self.PlatformInfo.OutputDir,
 644             "ffs_output_directory"      : self._AutoGenObject.Macros["FFS_OUTPUT_DIR"],
 645             "platform_dir"              : self._AutoGenObject.Macros["PLATFORM_DIR"],
 646
 647             "module_name"               : self._AutoGenObject.Name,
 648             "module_guid"               : self._AutoGenObject.Guid,
 649             "module_name_guid"          : self._AutoGenObject._GetUniqueBaseName(),
 650             "module_version"            : self._AutoGenObject.Version,
 651             "module_type"               : self._AutoGenObject.ModuleType,
 652             "module_file"               : self._AutoGenObject.MetaFile.Name,
 653             "module_file_base_name"     : self._AutoGenObject.MetaFile.BaseName,
 654             "module_relative_directory" : self._AutoGenObject.SourceDir,
 655             "module_dir"                : mws.join (self.Macros["WORKSPACE"], self._AutoGenObject.SourceDir),
 656             "package_relative_directory": package_rel_dir,
 657             "module_extra_defines"      : ["%s = %s" % (k, v) for k, v in self._AutoGenObject.Module.Defines.iteritems()],
 658
 659             "architecture"              : self._AutoGenObject.Arch,
 660             "toolchain_tag"             : self._AutoGenObject.ToolChain,
 661             "build_target"              : self._AutoGenObject.BuildTarget,
 662
 663             "platform_build_directory"  : self.PlatformInfo.BuildDir,
 664             "module_build_directory"    : self._AutoGenObject.BuildDir,
 665             "module_output_directory"   : self._AutoGenObject.OutputDir,
 666             "module_debug_directory"    : self._AutoGenObject.DebugDir,
 667
 668             "separator"                 : Separator,
 669             "module_tool_definitions"   : ToolsDef,
 670
 671             "shell_command_code"        : self._SHELL_CMD_[self._FileType].keys(),
 672             "shell_command"             : self._SHELL_CMD_[self._FileType].values(),
 673
 674             "module_entry_point"        : ModuleEntryPoint,
 675             "image_entry_point"         : ImageEntryPoint,
 676             "arch_entry_point"          : ArchEntryPoint,
 677             "remaining_build_target"    : self.ResultFileList,
 678             "common_dependency_file"    : self.CommonFileDependency,
 679             "create_directory_command"  : self.GetCreateDirectoryCommand(self.IntermediateDirectoryList),
 680             "clean_command"             : self.GetRemoveDirectoryCommand(["$(OUTPUT_DIR)"]),
 681             "cleanall_command"          : self.GetRemoveDirectoryCommand(["$(DEBUG_DIR)", "$(OUTPUT_DIR)"]),
 682             "dependent_library_build_directory" : self.LibraryBuildDirectoryList,
 683             "library_build_command"     : LibraryMakeCommandList,
 684             "file_macro"                : FileMacroList,
 685             "file_build_target"         : self.BuildTargetList,
 686             "backward_compatible_target": BcTargetList,
 687         }
 688
 689         return MakefileTemplateDict
 690
 691     def ParserGenerateFfsCmd(self):
 692         #Add Ffs cmd to self.BuildTargetList
 693         OutputFile = ''
 694         DepsFileList = []
 695
 696         for Cmd in self.GenFfsList:
 697             if Cmd[2]:
 698                 for CopyCmd in Cmd[2]:
 699                     Src, Dst = CopyCmd
 700                     Src = self.ReplaceMacro(Src)
 701                     Dst = self.ReplaceMacro(Dst)
 702                     if Dst not in self.ResultFileList:
 703                         self.ResultFileList.append('%s' % Dst)
 704                     if '%s :' %(Dst) not in self.BuildTargetList:
 705                         self.BuildTargetList.append("%s :" %(Dst))
 706                         self.BuildTargetList.append('\t' + self._CP_TEMPLATE_[self._FileType] %{'Src': Src, 'Dst': Dst})
 707
 708             FfsCmdList = Cmd[0]
 709             for index, Str in enumerate(FfsCmdList):
 710                 if '-o' == Str:
 711                     OutputFile = FfsCmdList[index + 1]
 712                 if '-i' == Str:
 713                     if DepsFileList == []:
 714                         DepsFileList = [FfsCmdList[index + 1]]
 715                     else:
 716                         DepsFileList.append(FfsCmdList[index + 1])
 717             DepsFileString = ' '.join(DepsFileList).strip()
 718             if DepsFileString == '':
 719                 continue
 720             OutputFile = self.ReplaceMacro(OutputFile)
 721             self.ResultFileList.append('%s' % OutputFile)
 722             DepsFileString = self.ReplaceMacro(DepsFileString)
 723             self.BuildTargetList.append('%s : %s' % (OutputFile, DepsFileString))
 724             CmdString = ' '.join(FfsCmdList).strip()
 725             CmdString = self.ReplaceMacro(CmdString)
 726             self.BuildTargetList.append('\t%s' % CmdString)
 727
 728             self.ParseSecCmd(DepsFileList, Cmd[1])
 729             for SecOutputFile, SecDepsFile, SecCmd in self.FfsOutputFileList :
 730                 self.BuildTargetList.append('%s : %s' % (self.ReplaceMacro(SecOutputFile), self.ReplaceMacro(SecDepsFile)))
 731                 self.BuildTargetList.append('\t%s' % self.ReplaceMacro(SecCmd))
 732             self.FfsOutputFileList = []
 733
 734     def ParseSecCmd(self, OutputFileList, CmdTuple):
 735         for OutputFile in OutputFileList:
 736             for SecCmdStr in CmdTuple:
 737                 SecDepsFileList = []
 738                 SecCmdList = SecCmdStr.split()
 739                 CmdName = SecCmdList[0]
 740                 for index, CmdItem in enumerate(SecCmdList):
 741                     if '-o' == CmdItem and OutputFile == SecCmdList[index + 1]:
 742                         index = index + 1
 743                         while index + 1 < len(SecCmdList):
 744                             if not SecCmdList[index+1].startswith('-'):
 745                                 SecDepsFileList.append(SecCmdList[index + 1])
 746                             index = index + 1
 747                         if CmdName == 'Trim':
 748                             SecDepsFileList.append(os.path.join('$(DEBUG_DIR)', os.path.basename(OutputFile).replace('offset', 'efi')))
 749                         if OutputFile.endswith('.ui') or OutputFile.endswith('.ver'):
 750                             SecDepsFileList.append(os.path.join('$(MODULE_DIR)','$(MODULE_FILE)'))
 751                         self.FfsOutputFileList.append((OutputFile, ' '.join(SecDepsFileList), SecCmdStr))
 752                         if len(SecDepsFileList) > 0:
 753                             self.ParseSecCmd(SecDepsFileList, CmdTuple)
 754                         break
 755                     else:
 756                         continue
 757
 758     def ReplaceMacro(self, str):
 759         for Macro in self.MacroList:
 760             if self._AutoGenObject.Macros[Macro] and self._AutoGenObject.Macros[Macro] in str:
 761                 str = str.replace(self._AutoGenObject.Macros[Macro], '$(' + Macro + ')')
 762         return str
 763
 764     def CommandExceedLimit(self):
 765         FlagDict = {
 766                     'CC'    :  { 'Macro' : '$(CC_FLAGS)',    'Value' : False},
 767                     'PP'    :  { 'Macro' : '$(PP_FLAGS)',    'Value' : False},
 768                     'APP'   :  { 'Macro' : '$(APP_FLAGS)',   'Value' : False},
 769                     'ASLPP' :  { 'Macro' : '$(ASLPP_FLAGS)', 'Value' : False},
 770                     'VFRPP' :  { 'Macro' : '$(VFRPP_FLAGS)', 'Value' : False},
 771                     'ASM'   :  { 'Macro' : '$(ASM_FLAGS)',   'Value' : False},
 772                     'ASLCC' :  { 'Macro' : '$(ASLCC_FLAGS)', 'Value' : False},
 773                    }
 774
 775         RespDict = {}
 776         FileTypeList = []
 777         IncPrefix = self._INC_FLAG_[self._AutoGenObject.ToolChainFamily]
 778
 779         # base on the source files to decide the file type
 780         for File in self._AutoGenObject.SourceFileList:
 781             for type in self._AutoGenObject.FileTypes:
 782                 if File in self._AutoGenObject.FileTypes[type]:
 783                     if type not in FileTypeList:
 784                         FileTypeList.append(type)
 785
 786         # calculate the command-line length
 787         if FileTypeList:
 788             for type in FileTypeList:
 789                 BuildTargets = self._AutoGenObject.BuildRules[type].BuildTargets
 790                 for Target in BuildTargets:
 791                     CommandList = BuildTargets[Target].Commands
 792                     for SingleCommand in CommandList:
 793                         Tool = ''
 794                         SingleCommandLength = len(SingleCommand)
 795                         SingleCommandList = SingleCommand.split()
 796                         if len(SingleCommandList) > 0:
 797                             for Flag in FlagDict.keys():
 798                                 if '$('+ Flag +')' in SingleCommandList[0]:
 799                                     Tool = Flag
 800                                     break
 801                         if Tool:
 802                             if 'PATH' not in self._AutoGenObject._BuildOption[Tool]:
 803                                 EdkLogger.error("build", AUTOGEN_ERROR, "%s_PATH doesn't exist in %s ToolChain and %s Arch." %(Tool, self._AutoGenObject.ToolChain, self._AutoGenObject.Arch), ExtraData="[%s]" % str(self._AutoGenObject))
 804                             SingleCommandLength += len(self._AutoGenObject._BuildOption[Tool]['PATH'])
 805                             for item in SingleCommandList[1:]:
 806                                 if FlagDict[Tool]['Macro'] in item:
 807                                     if 'FLAGS' not in self._AutoGenObject._BuildOption[Tool]:
 808                                         EdkLogger.error("build", AUTOGEN_ERROR, "%s_FLAGS doesn't exist in %s ToolChain and %s Arch." %(Tool, self._AutoGenObject.ToolChain, self._AutoGenObject.Arch), ExtraData="[%s]" % str(self._AutoGenObject))
 809                                     Str = self._AutoGenObject._BuildOption[Tool]['FLAGS']
 810                                     for Option in self._AutoGenObject.BuildOption.keys():
 811                                         for Attr in self._AutoGenObject.BuildOption[Option]:
 812                                             if Str.find(Option + '_' + Attr) != -1:
 813                                                 Str = Str.replace('$(' + Option + '_' + Attr + ')', self._AutoGenObject.BuildOption[Option][Attr])
 814                                     while(Str.find('$(') != -1):
 815                                         for macro in self._AutoGenObject.Macros.keys():
 816                                             MacroName = '$('+ macro + ')'
 817                                             if (Str.find(MacroName) != -1):
 818                                                 Str = Str.replace(MacroName, self._AutoGenObject.Macros[macro])
 819                                                 break
 820                                         else:
 821                                             break
 822                                     SingleCommandLength += len(Str)
 823                                 elif '$(INC)' in item:
 824                                     SingleCommandLength += self._AutoGenObject.IncludePathLength + len(IncPrefix) * len(self._AutoGenObject._IncludePathList)
 825                                 elif item.find('$(') != -1:
 826                                     Str = item
 827                                     for Option in self._AutoGenObject.BuildOption.keys():
 828                                         for Attr in self._AutoGenObject.BuildOption[Option]:
 829                                             if Str.find(Option + '_' + Attr) != -1:
 830                                                 Str = Str.replace('$(' + Option + '_' + Attr + ')', self._AutoGenObject.BuildOption[Option][Attr])
 831                                     while(Str.find('$(') != -1):
 832                                         for macro in self._AutoGenObject.Macros.keys():
 833                                             MacroName = '$('+ macro + ')'
 834                                             if (Str.find(MacroName) != -1):
 835                                                 Str = Str.replace(MacroName, self._AutoGenObject.Macros[macro])
 836                                                 break
 837                                         else:
 838                                             break
 839                                     SingleCommandLength += len(Str)
 840
 841                             if SingleCommandLength > GlobalData.gCommandMaxLength:
 842                                 FlagDict[Tool]['Value'] = True
 843
 844                 # generate the response file content by combine the FLAGS and INC
 845                 for Flag in FlagDict.keys():
 846                     if FlagDict[Flag]['Value']:
 847                         Key = Flag + '_RESP'
 848                         RespMacro = FlagDict[Flag]['Macro'].replace('FLAGS', 'RESP')
 849                         Value = self._AutoGenObject.BuildOption[Flag]['FLAGS']
 850                         for inc in self._AutoGenObject._IncludePathList:
 851                             Value += ' ' + IncPrefix + inc
 852                         for Option in self._AutoGenObject.BuildOption.keys():
 853                             for Attr in self._AutoGenObject.BuildOption[Option]:
 854                                 if Value.find(Option + '_' + Attr) != -1:
 855                                     Value = Value.replace('$(' + Option + '_' + Attr + ')', self._AutoGenObject.BuildOption[Option][Attr])
 856                         while (Value.find('$(') != -1):
 857                             for macro in self._AutoGenObject.Macros.keys():
 858                                 MacroName = '$('+ macro + ')'
 859                                 if (Value.find(MacroName) != -1):
 860                                     Value = Value.replace(MacroName, self._AutoGenObject.Macros[macro])
 861                                     break
 862                             else:
 863                                 break
 864
 865                         if self._AutoGenObject.ToolChainFamily == 'GCC':
 866                             RespDict[Key] = Value.replace('\\', '/')
 867                         else:
 868                             RespDict[Key] = Value
 869                         for Target in BuildTargets:
 870                             for i, SingleCommand in enumerate(BuildTargets[Target].Commands):
 871                                 if FlagDict[Flag]['Macro'] in SingleCommand:
 872                                     BuildTargets[Target].Commands[i] = SingleCommand.replace('$(INC)','').replace(FlagDict[Flag]['Macro'], RespMacro)
 873         return RespDict
 874
 875     def ProcessBuildTargetList(self):
 876         #
 877         # Search dependency file list for each source file
 878         #
 879         ForceIncludedFile = []
 880         for File in self._AutoGenObject.AutoGenFileList:
 881             if File.Ext == '.h':
 882                 ForceIncludedFile.append(File)
 883         SourceFileList = []
 884         OutPutFileList = []
 885         for Target in self._AutoGenObject.IntroTargetList:
 886             SourceFileList.extend(Target.Inputs)
 887             OutPutFileList.extend(Target.Outputs)
 888
 889         if OutPutFileList:
 890             for Item in OutPutFileList:
 891                 if Item in SourceFileList:
 892                     SourceFileList.remove(Item)
 893
 894         self.FileDependency = self.GetFileDependency(
 895                                     SourceFileList,
 896                                     ForceIncludedFile,
 897                                     self._AutoGenObject.IncludePathList + self._AutoGenObject.BuildOptionIncPathList
 898                                     )
 899         DepSet = None
 900         for File in self.FileDependency:
 901             if not self.FileDependency[File]:
 902                 self.FileDependency[File] = ['$(FORCE_REBUILD)']
 903                 continue
 904
 905             self._AutoGenObject.AutoGenDepSet |= set(self.FileDependency[File])
 906
 907             # skip non-C files
 908             if File.Ext not in [".c", ".C"] or File.Name == "AutoGen.c":
 909                 continue
 910             elif DepSet is None:
 911                 DepSet = set(self.FileDependency[File])
 912             else:
 913                 DepSet &= set(self.FileDependency[File])
 914         # in case nothing in SourceFileList
 915         if DepSet is None:
 916             DepSet = set()
 917         #
 918         # Extract common files list in the dependency files
 919         #
 920         for File in DepSet:
 921             self.CommonFileDependency.append(self.PlaceMacro(File.Path, self.Macros))
 922
 923         for File in self.FileDependency:
 924             # skip non-C files
 925             if File.Ext not in [".c", ".C"] or File.Name == "AutoGen.c":
 926                 continue
 927             NewDepSet = set(self.FileDependency[File])
 928             NewDepSet -= DepSet
 929             self.FileDependency[File] = ["$(COMMON_DEPS)"] + list(NewDepSet)
 930
 931         # Convert target description object to target string in makefile
 932         for Type in self._AutoGenObject.Targets:
 933             for T in self._AutoGenObject.Targets[Type]:
 934                 # Generate related macros if needed
 935                 if T.GenFileListMacro and T.FileListMacro not in self.FileListMacros:
 936                     self.FileListMacros[T.FileListMacro] = []
 937                 if T.GenListFile and T.ListFileMacro not in self.ListFileMacros:
 938                     self.ListFileMacros[T.ListFileMacro] = []
 939                 if T.GenIncListFile and T.IncListFileMacro not in self.ListFileMacros:
 940                     self.ListFileMacros[T.IncListFileMacro] = []
 941
 942                 Deps = []
 943                 # Add force-dependencies
 944                 for Dep in T.Dependencies:
 945                     Deps.append(self.PlaceMacro(str(Dep), self.Macros))
 946                 # Add inclusion-dependencies
 947                 if len(T.Inputs) == 1 and T.Inputs[0] in self.FileDependency:
 948                     for F in self.FileDependency[T.Inputs[0]]:
 949                         Deps.append(self.PlaceMacro(str(F), self.Macros))
 950                 # Add source-dependencies
 951                 for F in T.Inputs:
 952                     NewFile = self.PlaceMacro(str(F), self.Macros)
 953                     # In order to use file list macro as dependency
 954                     if T.GenListFile:
 955                         # gnu tools need forward slash path separater, even on Windows
 956                         self.ListFileMacros[T.ListFileMacro].append(str(F).replace ('\\', '/'))
 957                         self.FileListMacros[T.FileListMacro].append(NewFile)
 958                     elif T.GenFileListMacro:
 959                         self.FileListMacros[T.FileListMacro].append(NewFile)
 960                     else:
 961                         Deps.append(NewFile)
 962
 963                 # Use file list macro as dependency
 964                 if T.GenFileListMacro:
 965                     Deps.append("$(%s)" % T.FileListMacro)
 966                     if Type in [TAB_OBJECT_FILE, TAB_STATIC_LIBRARY]:
 967                         Deps.append("$(%s)" % T.ListFileMacro)
 968
 969                 TargetDict = {
 970                     "target"    :   self.PlaceMacro(T.Target.Path, self.Macros),
 971                     "cmd"       :   "\n\t".join(T.Commands),
 972                     "deps"      :   Deps
 973                 }
 974                 self.BuildTargetList.append(self._BUILD_TARGET_TEMPLATE.Replace(TargetDict))
 975
 976     ## For creating makefile targets for dependent libraries
 977     def ProcessDependentLibrary(self):
 978         for LibraryAutoGen in self._AutoGenObject.LibraryAutoGenList:
 979             if not LibraryAutoGen.IsBinaryModule:
 980                 self.LibraryBuildDirectoryList.append(self.PlaceMacro(LibraryAutoGen.BuildDir, self.Macros))
 981
 982     ## Return a list containing source file's dependencies
 983     #
 984     #   @param      FileList        The list of source files
 985     #   @param      ForceInculeList The list of files which will be included forcely
 986     #   @param      SearchPathList  The list of search path
 987     #
 988     #   @retval     dict            The mapping between source file path and its dependencies
 989     #
 990     def GetFileDependency(self, FileList, ForceInculeList, SearchPathList):
 991         Dependency = {}
 992         for F in FileList:
 993             Dependency[F] = self.GetDependencyList(F, ForceInculeList, SearchPathList)
 994         return Dependency
 995
 996     ## Find dependencies for one source file
 997     #
 998     #  By searching recursively "#include" directive in file, find out all the
 999     #  files needed by given source file. The dependecies will be only searched
1000     #  in given search path list.
1001     #
1002     #   @param      File            The source file
1003     #   @param      ForceInculeList The list of files which will be included forcely
1004     #   @param      SearchPathList  The list of search path
1005     #
1006     #   @retval     list            The list of files the given source file depends on
1007     #
1008     def GetDependencyList(self, File, ForceList, SearchPathList):
1009         EdkLogger.debug(EdkLogger.DEBUG_1, "Try to get dependency files for %s" % File)
1010         FileStack = [File] + ForceList
1011         DependencySet = set()
1012
1013         if self._AutoGenObject.Arch not in gDependencyDatabase:
1014             gDependencyDatabase[self._AutoGenObject.Arch] = {}
1015         DepDb = gDependencyDatabase[self._AutoGenObject.Arch]
1016
1017         while len(FileStack) > 0:
1018             F = FileStack.pop()
1019
1020             FullPathDependList = []
1021             if F in self.FileCache:
1022                 for CacheFile in self.FileCache[F]:
1023                     FullPathDependList.append(CacheFile)
1024                     if CacheFile not in DependencySet:
1025                         FileStack.append(CacheFile)
1026                 DependencySet.update(FullPathDependList)
1027                 continue
1028
1029             CurrentFileDependencyList = []
1030             if F in DepDb:
1031                 CurrentFileDependencyList = DepDb[F]
1032             else:
1033                 try:
1034                     Fd = open(F.Path, 'r')
1035                 except BaseException, X:
1036                     EdkLogger.error("build", FILE_OPEN_FAILURE, ExtraData=F.Path + "\n\t" + str(X))
1037
1038                 FileContent = Fd.read()
1039                 Fd.close()
1040                 if len(FileContent) == 0:
1041                     continue
1042
1043                 if FileContent[0] == 0xff or FileContent[0] == 0xfe:
1044                     FileContent = unicode(FileContent, "utf-16")
1045                 IncludedFileList = gIncludePattern.findall(FileContent)
1046
1047                 for Inc in IncludedFileList:
1048                     Inc = Inc.strip()
1049                     # if there's macro used to reference header file, expand it
1050                     HeaderList = gMacroPattern.findall(Inc)
1051                     if len(HeaderList) == 1 and len(HeaderList[0]) == 2:
1052                         HeaderType = HeaderList[0][0]
1053                         HeaderKey = HeaderList[0][1]
1054                         if HeaderType in gIncludeMacroConversion:
1055                             Inc = gIncludeMacroConversion[HeaderType] % {"HeaderKey" : HeaderKey}
1056                         else:
1057                             # not known macro used in #include, always build the file by
1058                             # returning a empty dependency
1059                             self.FileCache[File] = []
1060                             return []
1061                     Inc = os.path.normpath(Inc)
1062                     CurrentFileDependencyList.append(Inc)
1063                 DepDb[F] = CurrentFileDependencyList
1064
1065             CurrentFilePath = F.Dir
1066             PathList = [CurrentFilePath] + SearchPathList
1067             for Inc in CurrentFileDependencyList:
1068                 for SearchPath in PathList:
1069                     FilePath = os.path.join(SearchPath, Inc)
1070                     if FilePath in gIsFileMap:
1071                         if not gIsFileMap[FilePath]:
1072                             continue
1073                     # If isfile is called too many times, the performance is slow down.
1074                     elif not os.path.isfile(FilePath):
1075                         gIsFileMap[FilePath] = False
1076                         continue
1077                     else:
1078                         gIsFileMap[FilePath] = True
1079                     FilePath = PathClass(FilePath)
1080                     FullPathDependList.append(FilePath)
1081                     if FilePath not in DependencySet:
1082                         FileStack.append(FilePath)
1083                     break
1084                 else:
1085                     EdkLogger.debug(EdkLogger.DEBUG_9, "%s included by %s was not found "\
1086                                     "in any given path:\n\t%s" % (Inc, F, "\n\t".join(SearchPathList)))
1087
1088             self.FileCache[F] = FullPathDependList
1089             DependencySet.update(FullPathDependList)
1090
1091         DependencySet.update(ForceList)
1092         if File in DependencySet:
1093             DependencySet.remove(File)
1094         DependencyList = list(DependencySet)  # remove duplicate ones
1095
1096         return DependencyList
1097
1098     _TemplateDict = property(_CreateTemplateDict)
1099
1100 ## CustomMakefile class
1101 #
1102 #  This class encapsules makefie and its generation for module. It uses template to generate
1103 #  the content of makefile. The content of makefile will be got from ModuleAutoGen object.
1104 #
1105 class CustomMakefile(BuildFile):
1106     ## template used to generate the makefile for module with custom makefile
1107     _TEMPLATE_ = TemplateString('''\
1108 ${makefile_header}
1109
1110 #
1111 # Platform Macro Definition
1112 #
1113 PLATFORM_NAME = ${platform_name}
1114 PLATFORM_GUID = ${platform_guid}
1115 PLATFORM_VERSION = ${platform_version}
1116 PLATFORM_RELATIVE_DIR = ${platform_relative_directory}
1117 PLATFORM_DIR = ${platform_dir}
1118 PLATFORM_OUTPUT_DIR = ${platform_output_directory}
1119
1120 #
1121 # Module Macro Definition
1122 #
1123 MODULE_NAME = ${module_name}
1124 MODULE_GUID = ${module_guid}
1125 MODULE_NAME_GUID = ${module_name_guid}
1126 MODULE_VERSION = ${module_version}
1127 MODULE_TYPE = ${module_type}
1128 MODULE_FILE = ${module_file}
1129 MODULE_FILE_BASE_NAME = ${module_file_base_name}
1130 BASE_NAME = $(MODULE_NAME)
1131 MODULE_RELATIVE_DIR = ${module_relative_directory}
1132 MODULE_DIR = ${module_dir}
1133
1134 #
1135 # Build Configuration Macro Definition
1136 #
1137 ARCH = ${architecture}
1138 TOOLCHAIN = ${toolchain_tag}
1139 TOOLCHAIN_TAG = ${toolchain_tag}
1140 TARGET = ${build_target}
1141
1142 #
1143 # Build Directory Macro Definition
1144 #
1145 # PLATFORM_BUILD_DIR = ${platform_build_directory}
1146 BUILD_DIR = ${platform_build_directory}
1147 BIN_DIR = $(BUILD_DIR)${separator}${architecture}
1148 LIB_DIR = $(BIN_DIR)
1149 MODULE_BUILD_DIR = ${module_build_directory}
1150 OUTPUT_DIR = ${module_output_directory}
1151 DEBUG_DIR = ${module_debug_directory}
1152 DEST_DIR_OUTPUT = $(OUTPUT_DIR)
1153 DEST_DIR_DEBUG = $(DEBUG_DIR)
1154
1155 #
1156 # Tools definitions specific to this module
1157 #
1158 ${BEGIN}${module_tool_definitions}
1159 ${END}
1160 MAKE_FILE = ${makefile_path}
1161
1162 #
1163 # Shell Command Macro
1164 #
1165 ${BEGIN}${shell_command_code} = ${shell_command}
1166 ${END}
1167
1168 ${custom_makefile_content}
1169
1170 #
1171 # Target used when called from platform makefile, which will bypass the build of dependent libraries
1172 #
1173
1174 pbuild: init all
1175
1176
1177 #
1178 # ModuleTarget
1179 #
1180
1181 mbuild: init all
1182
1183 #
1184 # Build Target used in multi-thread build mode, which no init target is needed
1185 #
1186
1187 tbuild: all
1188
1189 #
1190 # Initialization target: print build information and create necessary directories
1191 #
1192 init:
1193 \t-@echo Building ... $(MODULE_DIR)${separator}$(MODULE_FILE) [$(ARCH)]
1194 ${BEGIN}\t-@${create_directory_command}\n${END}\
1195
1196 ''')
1197
1198     ## Constructor of CustomMakefile
1199     #
1200     #   @param  ModuleAutoGen   Object of ModuleAutoGen class
1201     #
1202     def __init__(self, ModuleAutoGen):
1203         BuildFile.__init__(self, ModuleAutoGen)
1204         self.PlatformInfo = self._AutoGenObject.PlatformInfo
1205         self.IntermediateDirectoryList = ["$(DEBUG_DIR)", "$(OUTPUT_DIR)"]
1206
1207     # Compose a dict object containing information used to do replacement in template
1208     def _CreateTemplateDict(self):
1209         Separator = self._SEP_[self._FileType]
1210         if self._FileType not in self._AutoGenObject.CustomMakefile:
1211             EdkLogger.error('build', OPTION_NOT_SUPPORTED, "No custom makefile for %s" % self._FileType,
1212                             ExtraData="[%s]" % str(self._AutoGenObject))
1213         MakefilePath = mws.join(
1214                                 self._AutoGenObject.WorkspaceDir,
1215                                 self._AutoGenObject.CustomMakefile[self._FileType]
1216                                 )
1217         try:
1218             CustomMakefile = open(MakefilePath, 'r').read()
1219         except:
1220             EdkLogger.error('build', FILE_OPEN_FAILURE, File=str(self._AutoGenObject),
1221                             ExtraData=self._AutoGenObject.CustomMakefile[self._FileType])
1222
1223         # tools definitions
1224         ToolsDef = []
1225         for Tool in self._AutoGenObject.BuildOption:
1226             # Don't generate MAKE_FLAGS in makefile. It's put in environment variable.
1227             if Tool == "MAKE":
1228                 continue
1229             for Attr in self._AutoGenObject.BuildOption[Tool]:
1230                 if Attr == "FAMILY":
1231                     continue
1232                 elif Attr == "PATH":
1233                     ToolsDef.append("%s = %s" % (Tool, self._AutoGenObject.BuildOption[Tool][Attr]))
1234                 else:
1235                     ToolsDef.append("%s_%s = %s" % (Tool, Attr, self._AutoGenObject.BuildOption[Tool][Attr]))
1236             ToolsDef.append("")
1237
1238         MakefileName = self._FILE_NAME_[self._FileType]
1239         MakefileTemplateDict = {
1240             "makefile_header"           : self._FILE_HEADER_[self._FileType],
1241             "makefile_path"             : os.path.join("$(MODULE_BUILD_DIR)", MakefileName),
1242             "platform_name"             : self.PlatformInfo.Name,
1243             "platform_guid"             : self.PlatformInfo.Guid,
1244             "platform_version"          : self.PlatformInfo.Version,
1245             "platform_relative_directory": self.PlatformInfo.SourceDir,
1246             "platform_output_directory" : self.PlatformInfo.OutputDir,
1247             "platform_dir"              : self._AutoGenObject.Macros["PLATFORM_DIR"],
1248
1249             "module_name"               : self._AutoGenObject.Name,
1250             "module_guid"               : self._AutoGenObject.Guid,
1251             "module_name_guid"          : self._AutoGenObject._GetUniqueBaseName(),
1252             "module_version"            : self._AutoGenObject.Version,
1253             "module_type"               : self._AutoGenObject.ModuleType,
1254             "module_file"               : self._AutoGenObject.MetaFile,
1255             "module_file_base_name"     : self._AutoGenObject.MetaFile.BaseName,
1256             "module_relative_directory" : self._AutoGenObject.SourceDir,
1257             "module_dir"                : mws.join (self._AutoGenObject.WorkspaceDir, self._AutoGenObject.SourceDir),
1258
1259             "architecture"              : self._AutoGenObject.Arch,
1260             "toolchain_tag"             : self._AutoGenObject.ToolChain,
1261             "build_target"              : self._AutoGenObject.BuildTarget,
1262
1263             "platform_build_directory"  : self.PlatformInfo.BuildDir,
1264             "module_build_directory"    : self._AutoGenObject.BuildDir,
1265             "module_output_directory"   : self._AutoGenObject.OutputDir,
1266             "module_debug_directory"    : self._AutoGenObject.DebugDir,
1267
1268             "separator"                 : Separator,
1269             "module_tool_definitions"   : ToolsDef,
1270
1271             "shell_command_code"        : self._SHELL_CMD_[self._FileType].keys(),
1272             "shell_command"             : self._SHELL_CMD_[self._FileType].values(),
1273
1274             "create_directory_command"  : self.GetCreateDirectoryCommand(self.IntermediateDirectoryList),
1275             "custom_makefile_content"   : CustomMakefile
1276         }
1277
1278         return MakefileTemplateDict
1279
1280     _TemplateDict = property(_CreateTemplateDict)
1281
1282 ## PlatformMakefile class
1283 #
1284 #  This class encapsules makefie and its generation for platform. It uses
1285 # template to generate the content of makefile. The content of makefile will be
1286 # got from PlatformAutoGen object.
1287 #
1288 class PlatformMakefile(BuildFile):
1289     ## template used to generate the makefile for platform
1290     _TEMPLATE_ = TemplateString('''\
1291 ${makefile_header}
1292
1293 #
1294 # Platform Macro Definition
1295 #
1296 PLATFORM_NAME = ${platform_name}
1297 PLATFORM_GUID = ${platform_guid}
1298 PLATFORM_VERSION = ${platform_version}
1299 PLATFORM_FILE = ${platform_file}
1300 PLATFORM_DIR = ${platform_dir}
1301 PLATFORM_OUTPUT_DIR = ${platform_output_directory}
1302
1303 #
1304 # Build Configuration Macro Definition
1305 #
1306 TOOLCHAIN = ${toolchain_tag}
1307 TOOLCHAIN_TAG = ${toolchain_tag}
1308 TARGET = ${build_target}
1309
1310 #
1311 # Build Directory Macro Definition
1312 #
1313 BUILD_DIR = ${platform_build_directory}
1314 FV_DIR = ${platform_build_directory}${separator}FV
1315
1316 #
1317 # Shell Command Macro
1318 #
1319 ${BEGIN}${shell_command_code} = ${shell_command}
1320 ${END}
1321
1322 MAKE = ${make_path}
1323 MAKE_FILE = ${makefile_path}
1324
1325 #
1326 # Default target
1327 #
1328 all: init build_libraries build_modules
1329
1330 #
1331 # Initialization target: print build information and create necessary directories
1332 #
1333 init:
1334 \t-@echo Building ... $(PLATFORM_FILE) [${build_architecture_list}]
1335 \t${BEGIN}-@${create_directory_command}
1336 \t${END}
1337 #
1338 # library build target
1339 #
1340 libraries: init build_libraries
1341
1342 #
1343 # module build target
1344 #
1345 modules: init build_libraries build_modules
1346
1347 #
1348 # Build all libraries:
1349 #
1350 build_libraries:
1351 ${BEGIN}\t@"$(MAKE)" $(MAKE_FLAGS) -f ${library_makefile_list} pbuild
1352 ${END}\t@cd $(BUILD_DIR)
1353
1354 #
1355 # Build all modules:
1356 #
1357 build_modules:
1358 ${BEGIN}\t@"$(MAKE)" $(MAKE_FLAGS) -f ${module_makefile_list} pbuild
1359 ${END}\t@cd $(BUILD_DIR)
1360
1361 #
1362 # Clean intermediate files
1363 #
1364 clean:
1365 \t${BEGIN}-@${library_build_command} clean
1366 \t${END}${BEGIN}-@${module_build_command} clean
1367 \t${END}@cd $(BUILD_DIR)
1368
1369 #
1370 # Clean all generated files except to makefile
1371 #
1372 cleanall:
1373 ${BEGIN}\t${cleanall_command}
1374 ${END}
1375
1376 #
1377 # Clean all library files
1378 #
1379 cleanlib:
1380 \t${BEGIN}-@${library_build_command} cleanall
1381 \t${END}@cd $(BUILD_DIR)\n
1382 ''')
1383
1384     ## Constructor of PlatformMakefile
1385     #
1386     #   @param  ModuleAutoGen   Object of PlatformAutoGen class
1387     #
1388     def __init__(self, PlatformAutoGen):
1389         BuildFile.__init__(self, PlatformAutoGen)
1390         self.ModuleBuildCommandList = []
1391         self.ModuleMakefileList = []
1392         self.IntermediateDirectoryList = []
1393         self.ModuleBuildDirectoryList = []
1394         self.LibraryBuildDirectoryList = []
1395         self.LibraryMakeCommandList = []
1396
1397     # Compose a dict object containing information used to do replacement in template
1398     def _CreateTemplateDict(self):
1399         Separator = self._SEP_[self._FileType]
1400
1401         PlatformInfo = self._AutoGenObject
1402         if "MAKE" not in PlatformInfo.ToolDefinition or "PATH" not in PlatformInfo.ToolDefinition["MAKE"]:
1403             EdkLogger.error("build", OPTION_MISSING, "No MAKE command defined. Please check your tools_def.txt!",
1404                             ExtraData="[%s]" % str(self._AutoGenObject))
1405
1406         self.IntermediateDirectoryList = ["$(BUILD_DIR)"]
1407         self.ModuleBuildDirectoryList = self.GetModuleBuildDirectoryList()
1408         self.LibraryBuildDirectoryList = self.GetLibraryBuildDirectoryList()
1409
1410         MakefileName = self._FILE_NAME_[self._FileType]
1411         LibraryMakefileList = []
1412         LibraryMakeCommandList = []
1413         for D in self.LibraryBuildDirectoryList:
1414             D = self.PlaceMacro(D, {"BUILD_DIR":PlatformInfo.BuildDir})
1415             Makefile = os.path.join(D, MakefileName)
1416             Command = self._MAKE_TEMPLATE_[self._FileType] % {"file":Makefile}
1417             LibraryMakefileList.append(Makefile)
1418             LibraryMakeCommandList.append(Command)
1419         self.LibraryMakeCommandList = LibraryMakeCommandList
1420
1421         ModuleMakefileList = []
1422         ModuleMakeCommandList = []
1423         for D in self.ModuleBuildDirectoryList:
1424             D = self.PlaceMacro(D, {"BUILD_DIR":PlatformInfo.BuildDir})
1425             Makefile = os.path.join(D, MakefileName)
1426             Command = self._MAKE_TEMPLATE_[self._FileType] % {"file":Makefile}
1427             ModuleMakefileList.append(Makefile)
1428             ModuleMakeCommandList.append(Command)
1429
1430         MakefileTemplateDict = {
1431             "makefile_header"           : self._FILE_HEADER_[self._FileType],
1432             "makefile_path"             : os.path.join("$(BUILD_DIR)", MakefileName),
1433             "make_path"                 : PlatformInfo.ToolDefinition["MAKE"]["PATH"],
1434             "makefile_name"             : MakefileName,
1435             "platform_name"             : PlatformInfo.Name,
1436             "platform_guid"             : PlatformInfo.Guid,
1437             "platform_version"          : PlatformInfo.Version,
1438             "platform_file"             : self._AutoGenObject.MetaFile,
1439             "platform_relative_directory": PlatformInfo.SourceDir,
1440             "platform_output_directory" : PlatformInfo.OutputDir,
1441             "platform_build_directory"  : PlatformInfo.BuildDir,
1442             "platform_dir"              : self._AutoGenObject.Macros["PLATFORM_DIR"],
1443
1444             "toolchain_tag"             : PlatformInfo.ToolChain,
1445             "build_target"              : PlatformInfo.BuildTarget,
1446             "shell_command_code"        : self._SHELL_CMD_[self._FileType].keys(),
1447             "shell_command"             : self._SHELL_CMD_[self._FileType].values(),
1448             "build_architecture_list"   : self._AutoGenObject.Arch,
1449             "architecture"              : self._AutoGenObject.Arch,
1450             "separator"                 : Separator,
1451             "create_directory_command"  : self.GetCreateDirectoryCommand(self.IntermediateDirectoryList),
1452             "cleanall_command"          : self.GetRemoveDirectoryCommand(self.IntermediateDirectoryList),
1453             "library_makefile_list"     : LibraryMakefileList,
1454             "module_makefile_list"      : ModuleMakefileList,
1455             "library_build_command"     : LibraryMakeCommandList,
1456             "module_build_command"      : ModuleMakeCommandList,
1457         }
1458
1459         return MakefileTemplateDict
1460
1461     ## Get the root directory list for intermediate files of all modules build
1462     #
1463     #   @retval     list    The list of directory
1464     #
1465     def GetModuleBuildDirectoryList(self):
1466         DirList = []
1467         for ModuleAutoGen in self._AutoGenObject.ModuleAutoGenList:
1468             if not ModuleAutoGen.IsBinaryModule:
1469                 DirList.append(os.path.join(self._AutoGenObject.BuildDir, ModuleAutoGen.BuildDir))
1470         return DirList
1471
1472     ## Get the root directory list for intermediate files of all libraries build
1473     #
1474     #   @retval     list    The list of directory
1475     #
1476     def GetLibraryBuildDirectoryList(self):
1477         DirList = []
1478         for LibraryAutoGen in self._AutoGenObject.LibraryAutoGenList:
1479             if not LibraryAutoGen.IsBinaryModule:
1480                 DirList.append(os.path.join(self._AutoGenObject.BuildDir, LibraryAutoGen.BuildDir))
1481         return DirList
1482
1483     _TemplateDict = property(_CreateTemplateDict)
1484
1485 ## TopLevelMakefile class
1486 #
1487 #  This class encapsules makefie and its generation for entrance makefile. It
1488 # uses template to generate the content of makefile. The content of makefile
1489 # will be got from WorkspaceAutoGen object.
1490 #
1491 class TopLevelMakefile(BuildFile):
1492     ## template used to generate toplevel makefile
1493     _TEMPLATE_ = TemplateString('''${BEGIN}\tGenFds -f ${fdf_file} --conf=${conf_directory} -o ${platform_build_directory} -t ${toolchain_tag} -b ${build_target} -p ${active_platform} -a ${build_architecture_list} ${extra_options}${END}${BEGIN} -r ${fd} ${END}${BEGIN} -i ${fv} ${END}${BEGIN} -C ${cap} ${END}${BEGIN} -D ${macro} ${END}''')
1494
1495     ## Constructor of TopLevelMakefile
1496     #
1497     #   @param  Workspace   Object of WorkspaceAutoGen class
1498     #
1499     def __init__(self, Workspace):
1500         BuildFile.__init__(self, Workspace)
1501         self.IntermediateDirectoryList = []
1502
1503     # Compose a dict object containing information used to do replacement in template
1504     def _CreateTemplateDict(self):
1505         Separator = self._SEP_[self._FileType]
1506
1507         # any platform autogen object is ok because we just need common information
1508         PlatformInfo = self._AutoGenObject
1509
1510         if "MAKE" not in PlatformInfo.ToolDefinition or "PATH" not in PlatformInfo.ToolDefinition["MAKE"]:
1511             EdkLogger.error("build", OPTION_MISSING, "No MAKE command defined. Please check your tools_def.txt!",
1512                             ExtraData="[%s]" % str(self._AutoGenObject))
1513
1514         for Arch in PlatformInfo.ArchList:
1515             self.IntermediateDirectoryList.append(Separator.join(["$(BUILD_DIR)", Arch]))
1516         self.IntermediateDirectoryList.append("$(FV_DIR)")
1517
1518         # TRICK: for not generating GenFds call in makefile if no FDF file
1519         MacroList = []
1520         if PlatformInfo.FdfFile is not None and PlatformInfo.FdfFile != "":
1521             FdfFileList = [PlatformInfo.FdfFile]
1522             # macros passed to GenFds
1523             MacroList.append('"%s=%s"' % ("EFI_SOURCE", GlobalData.gEfiSource.replace('\\', '\\\\')))
1524             MacroList.append('"%s=%s"' % ("EDK_SOURCE", GlobalData.gEdkSource.replace('\\', '\\\\')))
1525             MacroDict = {}
1526             MacroDict.update(GlobalData.gGlobalDefines)
1527             MacroDict.update(GlobalData.gCommandLineDefines)
1528             MacroDict.pop("EFI_SOURCE", "dummy")
1529             MacroDict.pop("EDK_SOURCE", "dummy")
1530             for MacroName in MacroDict:
1531                 if MacroDict[MacroName] != "":
1532                     MacroList.append('"%s=%s"' % (MacroName, MacroDict[MacroName].replace('\\', '\\\\')))
1533                 else:
1534                     MacroList.append('"%s"' % MacroName)
1535         else:
1536             FdfFileList = []
1537
1538         # pass extra common options to external program called in makefile, currently GenFds.exe
1539         ExtraOption = ''
1540         LogLevel = EdkLogger.GetLevel()
1541         if LogLevel == EdkLogger.VERBOSE:
1542             ExtraOption += " -v"
1543         elif LogLevel <= EdkLogger.DEBUG_9:
1544             ExtraOption += " -d %d" % (LogLevel - 1)
1545         elif LogLevel == EdkLogger.QUIET:
1546             ExtraOption += " -q"
1547
1548         if GlobalData.gCaseInsensitive:
1549             ExtraOption += " -c"
1550         if GlobalData.gEnableGenfdsMultiThread:
1551             ExtraOption += " --genfds-multi-thread"
1552         if GlobalData.gIgnoreSource:
1553             ExtraOption += " --ignore-sources"
1554
1555         for pcd in GlobalData.BuildOptionPcd:
1556             if pcd[2]:
1557                 pcdname = '.'.join(pcd[0:3])
1558             else:
1559                 pcdname = '.'.join(pcd[0:2])
1560             if pcd[3].startswith('{'):
1561                 ExtraOption += " --pcd " + pcdname + '=' + 'H' + '"' + pcd[3] + '"'
1562             else:
1563                 ExtraOption += " --pcd " + pcdname + '=' + pcd[3]
1564
1565         MakefileName = self._FILE_NAME_[self._FileType]
1566         SubBuildCommandList = []
1567         for A in PlatformInfo.ArchList:
1568             Command = self._MAKE_TEMPLATE_[self._FileType] % {"file":os.path.join("$(BUILD_DIR)", A, MakefileName)}
1569             SubBuildCommandList.append(Command)
1570
1571         MakefileTemplateDict = {
1572             "makefile_header"           : self._FILE_HEADER_[self._FileType],
1573             "makefile_path"             : os.path.join("$(BUILD_DIR)", MakefileName),
1574             "make_path"                 : PlatformInfo.ToolDefinition["MAKE"]["PATH"],
1575             "platform_name"             : PlatformInfo.Name,
1576             "platform_guid"             : PlatformInfo.Guid,
1577             "platform_version"          : PlatformInfo.Version,
1578             "platform_build_directory"  : PlatformInfo.BuildDir,
1579             "conf_directory"            : GlobalData.gConfDirectory,
1580
1581             "toolchain_tag"             : PlatformInfo.ToolChain,
1582             "build_target"              : PlatformInfo.BuildTarget,
1583             "shell_command_code"        : self._SHELL_CMD_[self._FileType].keys(),
1584             "shell_command"             : self._SHELL_CMD_[self._FileType].values(),
1585             'arch'                      : list(PlatformInfo.ArchList),
1586             "build_architecture_list"   : ','.join(PlatformInfo.ArchList),
1587             "separator"                 : Separator,
1588             "create_directory_command"  : self.GetCreateDirectoryCommand(self.IntermediateDirectoryList),
1589             "cleanall_command"          : self.GetRemoveDirectoryCommand(self.IntermediateDirectoryList),
1590             "sub_build_command"         : SubBuildCommandList,
1591             "fdf_file"                  : FdfFileList,
1592             "active_platform"           : str(PlatformInfo),
1593             "fd"                        : PlatformInfo.FdTargetList,
1594             "fv"                        : PlatformInfo.FvTargetList,
1595             "cap"                       : PlatformInfo.CapTargetList,
1596             "extra_options"             : ExtraOption,
1597             "macro"                     : MacroList,
1598         }
1599
1600         return MakefileTemplateDict
1601
1602     ## Get the root directory list for intermediate files of all modules build
1603     #
1604     #   @retval     list    The list of directory
1605     #
1606     def GetModuleBuildDirectoryList(self):
1607         DirList = []
1608         for ModuleAutoGen in self._AutoGenObject.ModuleAutoGenList:
1609             if not ModuleAutoGen.IsBinaryModule:
1610                 DirList.append(os.path.join(self._AutoGenObject.BuildDir, ModuleAutoGen.BuildDir))
1611         return DirList
1612
1613     ## Get the root directory list for intermediate files of all libraries build
1614     #
1615     #   @retval     list    The list of directory
1616     #
1617     def GetLibraryBuildDirectoryList(self):
1618         DirList = []
1619         for LibraryAutoGen in self._AutoGenObject.LibraryAutoGenList:
1620             if not LibraryAutoGen.IsBinaryModule:
1621                 DirList.append(os.path.join(self._AutoGenObject.BuildDir, LibraryAutoGen.BuildDir))
1622         return DirList
1623
1624     _TemplateDict = property(_CreateTemplateDict)
1625
1626 # This acts like the main() function for the script, unless it is 'import'ed into another script.
1627 if __name__ == '__main__':
1628     pass
1629