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.StringUtils import *
  26 from .BuildEngine import *
  27 import Common.GlobalData as GlobalData
  28 from collections import OrderedDict
  29 from Common.DataType import TAB_COMPILER_MSFT
  30
  31 ## Regular expression for finding header file inclusions
  32 gIncludePattern = re.compile(r"^[ \t]*#?[ \t]*include(?:[ \t]*(?:\\(?:\r\n|\r|\n))*[ \t]*)*(?:\(?[\"<]?[ \t]*)([-\w.\\/() \t]+)(?:[ \t]*[\">]?\)?)", re.MULTILINE | re.UNICODE | re.IGNORECASE)
  33
  34 ## Regular expression for matching macro used in header file inclusion
  35 gMacroPattern = re.compile("([_A-Z][_A-Z0-9]*)[ \t]*\((.+)\)", re.UNICODE)
  36
  37 gIsFileMap = {}
  38
  39 ## pattern for include style in Edk.x code
  40 gProtocolDefinition = "Protocol/%(HeaderKey)s/%(HeaderKey)s.h"
  41 gGuidDefinition = "Guid/%(HeaderKey)s/%(HeaderKey)s.h"
  42 gArchProtocolDefinition = "ArchProtocol/%(HeaderKey)s/%(HeaderKey)s.h"
  43 gPpiDefinition = "Ppi/%(HeaderKey)s/%(HeaderKey)s.h"
  44 gIncludeMacroConversion = {
  45   "EFI_PROTOCOL_DEFINITION"         :   gProtocolDefinition,
  46   "EFI_GUID_DEFINITION"             :   gGuidDefinition,
  47   "EFI_ARCH_PROTOCOL_DEFINITION"    :   gArchProtocolDefinition,
  48   "EFI_PROTOCOL_PRODUCER"           :   gProtocolDefinition,
  49   "EFI_PROTOCOL_CONSUMER"           :   gProtocolDefinition,
  50   "EFI_PROTOCOL_DEPENDENCY"         :   gProtocolDefinition,
  51   "EFI_ARCH_PROTOCOL_PRODUCER"      :   gArchProtocolDefinition,
  52   "EFI_ARCH_PROTOCOL_CONSUMER"      :   gArchProtocolDefinition,
  53   "EFI_ARCH_PROTOCOL_DEPENDENCY"    :   gArchProtocolDefinition,
  54   "EFI_PPI_DEFINITION"              :   gPpiDefinition,
  55   "EFI_PPI_PRODUCER"                :   gPpiDefinition,
  56   "EFI_PPI_CONSUMER"                :   gPpiDefinition,
  57   "EFI_PPI_DEPENDENCY"              :   gPpiDefinition,
  58 }
  59
  60 ## default makefile type
  61 gMakeType = ""
  62 if sys.platform == "win32":
  63     gMakeType = "nmake"
  64 else:
  65     gMakeType = "gmake"
  66
  67
  68 ## BuildFile class
  69 #
  70 #  This base class encapsules build file and its generation. It uses template to generate
  71 #  the content of build file. The content of build file will be got from AutoGen objects.
  72 #
  73 class BuildFile(object):
  74     ## template used to generate the build file (i.e. makefile if using make)
  75     _TEMPLATE_ = TemplateString('')
  76
  77     _DEFAULT_FILE_NAME_ = "Makefile"
  78
  79     ## default file name for each type of build file
  80     _FILE_NAME_ = {
  81         "nmake" :   "Makefile",
  82         "gmake" :   "GNUmakefile"
  83     }
  84
  85     ## Fixed header string for makefile
  86     _MAKEFILE_HEADER = '''#
  87 # DO NOT EDIT
  88 # This file is auto-generated by build utility
  89 #
  90 # Module Name:
  91 #
  92 #   %s
  93 #
  94 # Abstract:
  95 #
  96 #   Auto-generated makefile for building modules, libraries or platform
  97 #
  98     '''
  99
 100     ## Header string for each type of build file
 101     _FILE_HEADER_ = {
 102         "nmake" :   _MAKEFILE_HEADER % _FILE_NAME_["nmake"],
 103         "gmake" :   _MAKEFILE_HEADER % _FILE_NAME_["gmake"]
 104     }
 105
 106     ## shell commands which can be used in build file in the form of macro
 107     #   $(CP)     copy file command
 108     #   $(MV)     move file command
 109     #   $(RM)     remove file command
 110     #   $(MD)     create dir command
 111     #   $(RD)     remove dir command
 112     #
 113     _SHELL_CMD_ = {
 114         "nmake" : {
 115             "CP"    :   "copy /y",
 116             "MV"    :   "move /y",
 117             "RM"    :   "del /f /q",
 118             "MD"    :   "mkdir",
 119             "RD"    :   "rmdir /s /q",
 120         },
 121
 122         "gmake" : {
 123             "CP"    :   "cp -f",
 124             "MV"    :   "mv -f",
 125             "RM"    :   "rm -f",
 126             "MD"    :   "mkdir -p",
 127             "RD"    :   "rm -r -f",
 128         }
 129     }
 130
 131     ## directory separator
 132     _SEP_ = {
 133         "nmake" :   "\\",
 134         "gmake" :   "/"
 135     }
 136
 137     ## directory creation template
 138     _MD_TEMPLATE_ = {
 139         "nmake" :   'if not exist %(dir)s $(MD) %(dir)s',
 140         "gmake" :   "$(MD) %(dir)s"
 141     }
 142
 143     ## directory removal template
 144     _RD_TEMPLATE_ = {
 145         "nmake" :   'if exist %(dir)s $(RD) %(dir)s',
 146         "gmake" :   "$(RD) %(dir)s"
 147     }
 148     ## cp if exist
 149     _CP_TEMPLATE_ = {
 150         "nmake" :   'if exist %(Src)s $(CP) %(Src)s %(Dst)s',
 151         "gmake" :   "test -f %(Src)s && $(CP) %(Src)s %(Dst)s"
 152     }
 153
 154     _CD_TEMPLATE_ = {
 155         "nmake" :   'if exist %(dir)s cd %(dir)s',
 156         "gmake" :   "test -e %(dir)s && cd %(dir)s"
 157     }
 158
 159     _MAKE_TEMPLATE_ = {
 160         "nmake" :   'if exist %(file)s "$(MAKE)" $(MAKE_FLAGS) -f %(file)s',
 161         "gmake" :   'test -e %(file)s && "$(MAKE)" $(MAKE_FLAGS) -f %(file)s'
 162     }
 163
 164     _INCLUDE_CMD_ = {
 165         "nmake" :   '!INCLUDE',
 166         "gmake" :   "include"
 167     }
 168
 169     _INC_FLAG_ = {TAB_COMPILER_MSFT : "/I", "GCC" : "-I", "INTEL" : "-I", "RVCT" : "-I"}
 170
 171     ## Constructor of BuildFile
 172     #
 173     #   @param  AutoGenObject   Object of AutoGen class
 174     #
 175     def __init__(self, AutoGenObject):
 176         self._AutoGenObject = AutoGenObject
 177         self._FileType = gMakeType
 178
 179     ## Create build file
 180     #
 181     #   @param  FileType    Type of build file. Only nmake and gmake are supported now.
 182     #
 183     #   @retval TRUE        The build file is created or re-created successfully
 184     #   @retval FALSE       The build file exists and is the same as the one to be generated
 185     #
 186     def Generate(self, FileType=gMakeType):
 187         if FileType not in self._FILE_NAME_:
 188             EdkLogger.error("build", PARAMETER_INVALID, "Invalid build type [%s]" % FileType,
 189                             ExtraData="[%s]" % str(self._AutoGenObject))
 190         self._FileType = FileType
 191         FileContent = self._TEMPLATE_.Replace(self._TemplateDict)
 192         FileName = self._FILE_NAME_[FileType]
 193         return SaveFileOnChange(os.path.join(self._AutoGenObject.MakeFileDir, FileName), FileContent, False)
 194
 195     ## Return a list of directory creation command string
 196     #
 197     #   @param      DirList     The list of directory to be created
 198     #
 199     #   @retval     list        The directory creation command list
 200     #
 201     def GetCreateDirectoryCommand(self, DirList):
 202         return [self._MD_TEMPLATE_[self._FileType] % {'dir':Dir} for Dir in DirList]
 203
 204     ## Return a list of directory removal command string
 205     #
 206     #   @param      DirList     The list of directory to be removed
 207     #
 208     #   @retval     list        The directory removal command list
 209     #
 210     def GetRemoveDirectoryCommand(self, DirList):
 211         return [self._RD_TEMPLATE_[self._FileType] % {'dir':Dir} for Dir in DirList]
 212
 213     def PlaceMacro(self, Path, MacroDefinitions={}):
 214         if Path.startswith("$("):
 215             return Path
 216         else:
 217             PathLength = len(Path)
 218             for MacroName in MacroDefinitions:
 219                 MacroValue = MacroDefinitions[MacroName]
 220                 MacroValueLength = len(MacroValue)
 221                 if MacroValueLength == 0:
 222                     continue
 223                 if MacroValueLength <= PathLength and Path.startswith(MacroValue):
 224                     Path = "$(%s)%s" % (MacroName, Path[MacroValueLength:])
 225                     break
 226             return Path
 227
 228 ## ModuleMakefile class
 229 #
 230 #  This class encapsules makefie and its generation for module. It uses template to generate
 231 #  the content of makefile. The content of makefile will be got from ModuleAutoGen object.
 232 #
 233 class ModuleMakefile(BuildFile):
 234     ## template used to generate the makefile for module
 235     _TEMPLATE_ = TemplateString('''\
 236 ${makefile_header}
 237
 238 #
 239 # Platform Macro Definition
 240 #
 241 PLATFORM_NAME = ${platform_name}
 242 PLATFORM_GUID = ${platform_guid}
 243 PLATFORM_VERSION = ${platform_version}
 244 PLATFORM_RELATIVE_DIR = ${platform_relative_directory}
 245 PLATFORM_DIR = ${platform_dir}
 246 PLATFORM_OUTPUT_DIR = ${platform_output_directory}
 247
 248 #
 249 # Module Macro Definition
 250 #
 251 MODULE_NAME = ${module_name}
 252 MODULE_GUID = ${module_guid}
 253 MODULE_NAME_GUID = ${module_name_guid}
 254 MODULE_VERSION = ${module_version}
 255 MODULE_TYPE = ${module_type}
 256 MODULE_FILE = ${module_file}
 257 MODULE_FILE_BASE_NAME = ${module_file_base_name}
 258 BASE_NAME = $(MODULE_NAME)
 259 MODULE_RELATIVE_DIR = ${module_relative_directory}
 260 PACKAGE_RELATIVE_DIR = ${package_relative_directory}
 261 MODULE_DIR = ${module_dir}
 262 FFS_OUTPUT_DIR = ${ffs_output_directory}
 263
 264 MODULE_ENTRY_POINT = ${module_entry_point}
 265 ARCH_ENTRY_POINT = ${arch_entry_point}
 266 IMAGE_ENTRY_POINT = ${image_entry_point}
 267
 268 ${BEGIN}${module_extra_defines}
 269 ${END}
 270 #
 271 # Build Configuration Macro Definition
 272 #
 273 ARCH = ${architecture}
 274 TOOLCHAIN = ${toolchain_tag}
 275 TOOLCHAIN_TAG = ${toolchain_tag}
 276 TARGET = ${build_target}
 277
 278 #
 279 # Build Directory Macro Definition
 280 #
 281 # PLATFORM_BUILD_DIR = ${platform_build_directory}
 282 BUILD_DIR = ${platform_build_directory}
 283 BIN_DIR = $(BUILD_DIR)${separator}${architecture}
 284 LIB_DIR = $(BIN_DIR)
 285 MODULE_BUILD_DIR = ${module_build_directory}
 286 OUTPUT_DIR = ${module_output_directory}
 287 DEBUG_DIR = ${module_debug_directory}
 288 DEST_DIR_OUTPUT = $(OUTPUT_DIR)
 289 DEST_DIR_DEBUG = $(DEBUG_DIR)
 290
 291 #
 292 # Shell Command Macro
 293 #
 294 ${BEGIN}${shell_command_code} = ${shell_command}
 295 ${END}
 296
 297 #
 298 # Tools definitions specific to this module
 299 #
 300 ${BEGIN}${module_tool_definitions}
 301 ${END}
 302 MAKE_FILE = ${makefile_path}
 303
 304 #
 305 # Build Macro
 306 #
 307 ${BEGIN}${file_macro}
 308 ${END}
 309
 310 COMMON_DEPS = ${BEGIN}${common_dependency_file} \\
 311               ${END}
 312
 313 #
 314 # Overridable Target Macro Definitions
 315 #
 316 FORCE_REBUILD = force_build
 317 INIT_TARGET = init
 318 PCH_TARGET =
 319 BC_TARGET = ${BEGIN}${backward_compatible_target} ${END}
 320 CODA_TARGET = ${BEGIN}${remaining_build_target} \\
 321               ${END}
 322
 323 #
 324 # Default target, which will build dependent libraries in addition to source files
 325 #
 326
 327 all: mbuild
 328
 329
 330 #
 331 # Target used when called from platform makefile, which will bypass the build of dependent libraries
 332 #
 333
 334 pbuild: $(INIT_TARGET) $(BC_TARGET) $(PCH_TARGET) $(CODA_TARGET)
 335
 336 #
 337 # ModuleTarget
 338 #
 339
 340 mbuild: $(INIT_TARGET) $(BC_TARGET) gen_libs $(PCH_TARGET) $(CODA_TARGET)
 341
 342 #
 343 # Build Target used in multi-thread build mode, which will bypass the init and gen_libs targets
 344 #
 345
 346 tbuild: $(BC_TARGET) $(PCH_TARGET) $(CODA_TARGET)
 347
 348 #
 349 # Phony target which is used to force executing commands for a target
 350 #
 351 force_build:
 352 \t-@
 353
 354 #
 355 # Target to update the FD
 356 #
 357
 358 fds: mbuild gen_fds
 359
 360 #
 361 # Initialization target: print build information and create necessary directories
 362 #
 363 init: info dirs
 364
 365 info:
 366 \t-@echo Building ... $(MODULE_DIR)${separator}$(MODULE_FILE) [$(ARCH)]
 367
 368 dirs:
 369 ${BEGIN}\t-@${create_directory_command}\n${END}
 370
 371 strdefs:
 372 \t-@$(CP) $(DEBUG_DIR)${separator}AutoGen.h $(DEBUG_DIR)${separator}$(MODULE_NAME)StrDefs.h
 373
 374 #
 375 # GenLibsTarget
 376 #
 377 gen_libs:
 378 \t${BEGIN}@"$(MAKE)" $(MAKE_FLAGS) -f ${dependent_library_build_directory}${separator}${makefile_name}
 379 \t${END}@cd $(MODULE_BUILD_DIR)
 380
 381 #
 382 # Build Flash Device Image
 383 #
 384 gen_fds:
 385 \t@"$(MAKE)" $(MAKE_FLAGS) -f $(BUILD_DIR)${separator}${makefile_name} fds
 386 \t@cd $(MODULE_BUILD_DIR)
 387
 388 #
 389 # Individual Object Build Targets
 390 #
 391 ${BEGIN}${file_build_target}
 392 ${END}
 393
 394 #
 395 # clean all intermediate files
 396 #
 397 clean:
 398 \t${BEGIN}${clean_command}
 399 \t${END}\t$(RM) AutoGenTimeStamp
 400
 401 #
 402 # clean all generated files
 403 #
 404 cleanall:
 405 ${BEGIN}\t${cleanall_command}
 406 ${END}\t$(RM) *.pdb *.idb > NUL 2>&1
 407 \t$(RM) $(BIN_DIR)${separator}$(MODULE_NAME).efi
 408 \t$(RM) AutoGenTimeStamp
 409
 410 #
 411 # clean all dependent libraries built
 412 #
 413 cleanlib:
 414 \t${BEGIN}-@${library_build_command} cleanall
 415 \t${END}@cd $(MODULE_BUILD_DIR)\n\n''')
 416
 417     _FILE_MACRO_TEMPLATE = TemplateString("${macro_name} = ${BEGIN} \\\n    ${source_file}${END}\n")
 418     _BUILD_TARGET_TEMPLATE = TemplateString("${BEGIN}${target} : ${deps}\n${END}\t${cmd}\n")
 419
 420     ## Constructor of ModuleMakefile
 421     #
 422     #   @param  ModuleAutoGen   Object of ModuleAutoGen class
 423     #
 424     def __init__(self, ModuleAutoGen):
 425         BuildFile.__init__(self, ModuleAutoGen)
 426         self.PlatformInfo = self._AutoGenObject.PlatformInfo
 427
 428         self.ResultFileList = []
 429         self.IntermediateDirectoryList = ["$(DEBUG_DIR)", "$(OUTPUT_DIR)"]
 430
 431         self.FileBuildTargetList = []       # [(src, target string)]
 432         self.BuildTargetList = []           # [target string]
 433         self.PendingBuildTargetList = []    # [FileBuildRule objects]
 434         self.CommonFileDependency = []
 435         self.FileListMacros = {}
 436         self.ListFileMacros = {}
 437
 438         self.FileCache = {}
 439         self.LibraryBuildCommandList = []
 440         self.LibraryFileList = []
 441         self.LibraryMakefileList = []
 442         self.LibraryBuildDirectoryList = []
 443         self.SystemLibraryList = []
 444         self.Macros = OrderedDict()
 445         self.Macros["OUTPUT_DIR"      ] = self._AutoGenObject.Macros["OUTPUT_DIR"]
 446         self.Macros["DEBUG_DIR"       ] = self._AutoGenObject.Macros["DEBUG_DIR"]
 447         self.Macros["MODULE_BUILD_DIR"] = self._AutoGenObject.Macros["MODULE_BUILD_DIR"]
 448         self.Macros["BIN_DIR"         ] = self._AutoGenObject.Macros["BIN_DIR"]
 449         self.Macros["BUILD_DIR"       ] = self._AutoGenObject.Macros["BUILD_DIR"]
 450         self.Macros["WORKSPACE"       ] = self._AutoGenObject.Macros["WORKSPACE"]
 451         self.Macros["FFS_OUTPUT_DIR"  ] = self._AutoGenObject.Macros["FFS_OUTPUT_DIR"]
 452         self.GenFfsList                 = ModuleAutoGen.GenFfsList
 453         self.MacroList = ['FFS_OUTPUT_DIR', 'MODULE_GUID', 'OUTPUT_DIR']
 454         self.FfsOutputFileList = []
 455
 456     # Compose a dict object containing information used to do replacement in template
 457     @property
 458     def _TemplateDict(self):
 459         if self._FileType not in self._SEP_:
 460             EdkLogger.error("build", PARAMETER_INVALID, "Invalid Makefile type [%s]" % self._FileType,
 461                             ExtraData="[%s]" % str(self._AutoGenObject))
 462         MyAgo = self._AutoGenObject
 463         Separator = self._SEP_[self._FileType]
 464
 465         # break build if no source files and binary files are found
 466         if len(MyAgo.SourceFileList) == 0 and len(MyAgo.BinaryFileList) == 0:
 467             EdkLogger.error("build", AUTOGEN_ERROR, "No files to be built in module [%s, %s, %s]"
 468                             % (MyAgo.BuildTarget, MyAgo.ToolChain, MyAgo.Arch),
 469                             ExtraData="[%s]" % str(MyAgo))
 470
 471         # convert dependent libraries to build command
 472         self.ProcessDependentLibrary()
 473         if len(MyAgo.Module.ModuleEntryPointList) > 0:
 474             ModuleEntryPoint = MyAgo.Module.ModuleEntryPointList[0]
 475         else:
 476             ModuleEntryPoint = "_ModuleEntryPoint"
 477
 478         # Intel EBC compiler enforces EfiMain
 479         if MyAgo.AutoGenVersion < 0x00010005 and MyAgo.Arch == "EBC":
 480             ArchEntryPoint = "EfiMain"
 481         else:
 482             ArchEntryPoint = ModuleEntryPoint
 483
 484         if MyAgo.Arch == "EBC":
 485             # EBC compiler always use "EfiStart" as entry point. Only applies to EdkII modules
 486             ImageEntryPoint = "EfiStart"
 487         elif MyAgo.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 MyAgo.Module.Defines.iteritems():
 495             if k not in MyAgo.Macros:
 496                 MyAgo.Macros[k] = v
 497
 498         if 'MODULE_ENTRY_POINT' not in MyAgo.Macros:
 499             MyAgo.Macros['MODULE_ENTRY_POINT'] = ModuleEntryPoint
 500         if 'ARCH_ENTRY_POINT' not in MyAgo.Macros:
 501             MyAgo.Macros['ARCH_ENTRY_POINT'] = ArchEntryPoint
 502         if 'IMAGE_ENTRY_POINT' not in MyAgo.Macros:
 503             MyAgo.Macros['IMAGE_ENTRY_POINT'] = ImageEntryPoint
 504
 505         PCI_COMPRESS_Flag = False
 506         for k, v in MyAgo.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_[MyAgo.ToolChainFamily]
 513         for Tool in MyAgo.BuildOption:
 514             for Attr in MyAgo.BuildOption[Tool]:
 515                 Value = MyAgo.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, MyAgo.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(MyAgo.OutputDir, 'respfilelist.txt')
 541         if RespDict:
 542             RespFileListContent = ''
 543             for Resp in RespDict:
 544                 RespFile = os.path.join(MyAgo.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 MyAgo.CodaTargetList]
 566         if len(self.ResultFileList) == 0 and len(MyAgo.SourceFileList) != 0:
 567             EdkLogger.error("build", AUTOGEN_ERROR, "Nothing to build",
 568                             ExtraData="[%s]" % str(MyAgo))
 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  MyAgo.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(MyAgo.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 MyAgo.AutoGenVersion < 0x00010005 and len(MyAgo.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 = MyAgo.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"      : MyAgo.Macros["FFS_OUTPUT_DIR"],
 645             "platform_dir"              : MyAgo.Macros["PLATFORM_DIR"],
 646
 647             "module_name"               : MyAgo.Name,
 648             "module_guid"               : MyAgo.Guid,
 649             "module_name_guid"          : MyAgo.UniqueBaseName,
 650             "module_version"            : MyAgo.Version,
 651             "module_type"               : MyAgo.ModuleType,
 652             "module_file"               : MyAgo.MetaFile.Name,
 653             "module_file_base_name"     : MyAgo.MetaFile.BaseName,
 654             "module_relative_directory" : MyAgo.SourceDir,
 655             "module_dir"                : mws.join (self.Macros["WORKSPACE"], MyAgo.SourceDir),
 656             "package_relative_directory": package_rel_dir,
 657             "module_extra_defines"      : ["%s = %s" % (k, v) for k, v in MyAgo.Module.Defines.iteritems()],
 658
 659             "architecture"              : MyAgo.Arch,
 660             "toolchain_tag"             : MyAgo.ToolChain,
 661             "build_target"              : MyAgo.BuildTarget,
 662
 663             "platform_build_directory"  : self.PlatformInfo.BuildDir,
 664             "module_build_directory"    : MyAgo.BuildDir,
 665             "module_output_directory"   : MyAgo.OutputDir,
 666             "module_debug_directory"    : MyAgo.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(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(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:
 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:
 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:
 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:
 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:
 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:
 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:
 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:
 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         FileDependencyDict = self.GetFileDependency(
 895                                     SourceFileList,
 896                                     ForceIncludedFile,
 897                                     self._AutoGenObject.IncludePathList + self._AutoGenObject.BuildOptionIncPathList
 898                                     )
 899         DepSet = None
 900         for File,Dependency in FileDependencyDict.items():
 901             if not Dependency:
 902                 FileDependencyDict[File] = ['$(FORCE_REBUILD)']
 903                 continue
 904
 905             self._AutoGenObject.AutoGenDepSet |= set(Dependency)
 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(Dependency)
 912             else:
 913                 DepSet &= set(Dependency)
 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 FileDependencyDict:
 924             # skip non-C files
 925             if File.Ext not in [".c", ".C"] or File.Name == "AutoGen.c":
 926                 continue
 927             NewDepSet = set(FileDependencyDict[File])
 928             NewDepSet -= DepSet
 929             FileDependencyDict[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 FileDependencyDict:
 948                     for F in FileDependencyDict[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 as 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 ## CustomMakefile class
1099 #
1100 #  This class encapsules makefie and its generation for module. It uses template to generate
1101 #  the content of makefile. The content of makefile will be got from ModuleAutoGen object.
1102 #
1103 class CustomMakefile(BuildFile):
1104     ## template used to generate the makefile for module with custom makefile
1105     _TEMPLATE_ = TemplateString('''\
1106 ${makefile_header}
1107
1108 #
1109 # Platform Macro Definition
1110 #
1111 PLATFORM_NAME = ${platform_name}
1112 PLATFORM_GUID = ${platform_guid}
1113 PLATFORM_VERSION = ${platform_version}
1114 PLATFORM_RELATIVE_DIR = ${platform_relative_directory}
1115 PLATFORM_DIR = ${platform_dir}
1116 PLATFORM_OUTPUT_DIR = ${platform_output_directory}
1117
1118 #
1119 # Module Macro Definition
1120 #
1121 MODULE_NAME = ${module_name}
1122 MODULE_GUID = ${module_guid}
1123 MODULE_NAME_GUID = ${module_name_guid}
1124 MODULE_VERSION = ${module_version}
1125 MODULE_TYPE = ${module_type}
1126 MODULE_FILE = ${module_file}
1127 MODULE_FILE_BASE_NAME = ${module_file_base_name}
1128 BASE_NAME = $(MODULE_NAME)
1129 MODULE_RELATIVE_DIR = ${module_relative_directory}
1130 MODULE_DIR = ${module_dir}
1131
1132 #
1133 # Build Configuration Macro Definition
1134 #
1135 ARCH = ${architecture}
1136 TOOLCHAIN = ${toolchain_tag}
1137 TOOLCHAIN_TAG = ${toolchain_tag}
1138 TARGET = ${build_target}
1139
1140 #
1141 # Build Directory Macro Definition
1142 #
1143 # PLATFORM_BUILD_DIR = ${platform_build_directory}
1144 BUILD_DIR = ${platform_build_directory}
1145 BIN_DIR = $(BUILD_DIR)${separator}${architecture}
1146 LIB_DIR = $(BIN_DIR)
1147 MODULE_BUILD_DIR = ${module_build_directory}
1148 OUTPUT_DIR = ${module_output_directory}
1149 DEBUG_DIR = ${module_debug_directory}
1150 DEST_DIR_OUTPUT = $(OUTPUT_DIR)
1151 DEST_DIR_DEBUG = $(DEBUG_DIR)
1152
1153 #
1154 # Tools definitions specific to this module
1155 #
1156 ${BEGIN}${module_tool_definitions}
1157 ${END}
1158 MAKE_FILE = ${makefile_path}
1159
1160 #
1161 # Shell Command Macro
1162 #
1163 ${BEGIN}${shell_command_code} = ${shell_command}
1164 ${END}
1165
1166 ${custom_makefile_content}
1167
1168 #
1169 # Target used when called from platform makefile, which will bypass the build of dependent libraries
1170 #
1171
1172 pbuild: init all
1173
1174
1175 #
1176 # ModuleTarget
1177 #
1178
1179 mbuild: init all
1180
1181 #
1182 # Build Target used in multi-thread build mode, which no init target is needed
1183 #
1184
1185 tbuild: all
1186
1187 #
1188 # Initialization target: print build information and create necessary directories
1189 #
1190 init:
1191 \t-@echo Building ... $(MODULE_DIR)${separator}$(MODULE_FILE) [$(ARCH)]
1192 ${BEGIN}\t-@${create_directory_command}\n${END}\
1193
1194 ''')
1195
1196     ## Constructor of CustomMakefile
1197     #
1198     #   @param  ModuleAutoGen   Object of ModuleAutoGen class
1199     #
1200     def __init__(self, ModuleAutoGen):
1201         BuildFile.__init__(self, ModuleAutoGen)
1202         self.PlatformInfo = self._AutoGenObject.PlatformInfo
1203         self.IntermediateDirectoryList = ["$(DEBUG_DIR)", "$(OUTPUT_DIR)"]
1204
1205     # Compose a dict object containing information used to do replacement in template
1206     @property
1207     def _TemplateDict(self):
1208         Separator = self._SEP_[self._FileType]
1209         MyAgo = self._AutoGenObject
1210         if self._FileType not in MyAgo.CustomMakefile:
1211             EdkLogger.error('build', OPTION_NOT_SUPPORTED, "No custom makefile for %s" % self._FileType,
1212                             ExtraData="[%s]" % str(MyAgo))
1213         MakefilePath = mws.join(
1214                                 MyAgo.WorkspaceDir,
1215                                 MyAgo.CustomMakefile[self._FileType]
1216                                 )
1217         try:
1218             CustomMakefile = open(MakefilePath, 'r').read()
1219         except:
1220             EdkLogger.error('build', FILE_OPEN_FAILURE, File=str(MyAgo),
1221                             ExtraData=MyAgo.CustomMakefile[self._FileType])
1222
1223         # tools definitions
1224         ToolsDef = []
1225         for Tool in MyAgo.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 MyAgo.BuildOption[Tool]:
1230                 if Attr == "FAMILY":
1231                     continue
1232                 elif Attr == "PATH":
1233                     ToolsDef.append("%s = %s" % (Tool, MyAgo.BuildOption[Tool][Attr]))
1234                 else:
1235                     ToolsDef.append("%s_%s = %s" % (Tool, Attr, MyAgo.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"              : MyAgo.Macros["PLATFORM_DIR"],
1248
1249             "module_name"               : MyAgo.Name,
1250             "module_guid"               : MyAgo.Guid,
1251             "module_name_guid"          : MyAgo.UniqueBaseName,
1252             "module_version"            : MyAgo.Version,
1253             "module_type"               : MyAgo.ModuleType,
1254             "module_file"               : MyAgo.MetaFile,
1255             "module_file_base_name"     : MyAgo.MetaFile.BaseName,
1256             "module_relative_directory" : MyAgo.SourceDir,
1257             "module_dir"                : mws.join (MyAgo.WorkspaceDir, MyAgo.SourceDir),
1258
1259             "architecture"              : MyAgo.Arch,
1260             "toolchain_tag"             : MyAgo.ToolChain,
1261             "build_target"              : MyAgo.BuildTarget,
1262
1263             "platform_build_directory"  : self.PlatformInfo.BuildDir,
1264             "module_build_directory"    : MyAgo.BuildDir,
1265             "module_output_directory"   : MyAgo.OutputDir,
1266             "module_debug_directory"    : MyAgo.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 ## PlatformMakefile class
1281 #
1282 #  This class encapsules makefie and its generation for platform. It uses
1283 # template to generate the content of makefile. The content of makefile will be
1284 # got from PlatformAutoGen object.
1285 #
1286 class PlatformMakefile(BuildFile):
1287     ## template used to generate the makefile for platform
1288     _TEMPLATE_ = TemplateString('''\
1289 ${makefile_header}
1290
1291 #
1292 # Platform Macro Definition
1293 #
1294 PLATFORM_NAME = ${platform_name}
1295 PLATFORM_GUID = ${platform_guid}
1296 PLATFORM_VERSION = ${platform_version}
1297 PLATFORM_FILE = ${platform_file}
1298 PLATFORM_DIR = ${platform_dir}
1299 PLATFORM_OUTPUT_DIR = ${platform_output_directory}
1300
1301 #
1302 # Build Configuration Macro Definition
1303 #
1304 TOOLCHAIN = ${toolchain_tag}
1305 TOOLCHAIN_TAG = ${toolchain_tag}
1306 TARGET = ${build_target}
1307
1308 #
1309 # Build Directory Macro Definition
1310 #
1311 BUILD_DIR = ${platform_build_directory}
1312 FV_DIR = ${platform_build_directory}${separator}FV
1313
1314 #
1315 # Shell Command Macro
1316 #
1317 ${BEGIN}${shell_command_code} = ${shell_command}
1318 ${END}
1319
1320 MAKE = ${make_path}
1321 MAKE_FILE = ${makefile_path}
1322
1323 #
1324 # Default target
1325 #
1326 all: init build_libraries build_modules
1327
1328 #
1329 # Initialization target: print build information and create necessary directories
1330 #
1331 init:
1332 \t-@echo Building ... $(PLATFORM_FILE) [${build_architecture_list}]
1333 \t${BEGIN}-@${create_directory_command}
1334 \t${END}
1335 #
1336 # library build target
1337 #
1338 libraries: init build_libraries
1339
1340 #
1341 # module build target
1342 #
1343 modules: init build_libraries build_modules
1344
1345 #
1346 # Build all libraries:
1347 #
1348 build_libraries:
1349 ${BEGIN}\t@"$(MAKE)" $(MAKE_FLAGS) -f ${library_makefile_list} pbuild
1350 ${END}\t@cd $(BUILD_DIR)
1351
1352 #
1353 # Build all modules:
1354 #
1355 build_modules:
1356 ${BEGIN}\t@"$(MAKE)" $(MAKE_FLAGS) -f ${module_makefile_list} pbuild
1357 ${END}\t@cd $(BUILD_DIR)
1358
1359 #
1360 # Clean intermediate files
1361 #
1362 clean:
1363 \t${BEGIN}-@${library_build_command} clean
1364 \t${END}${BEGIN}-@${module_build_command} clean
1365 \t${END}@cd $(BUILD_DIR)
1366
1367 #
1368 # Clean all generated files except to makefile
1369 #
1370 cleanall:
1371 ${BEGIN}\t${cleanall_command}
1372 ${END}
1373
1374 #
1375 # Clean all library files
1376 #
1377 cleanlib:
1378 \t${BEGIN}-@${library_build_command} cleanall
1379 \t${END}@cd $(BUILD_DIR)\n
1380 ''')
1381
1382     ## Constructor of PlatformMakefile
1383     #
1384     #   @param  ModuleAutoGen   Object of PlatformAutoGen class
1385     #
1386     def __init__(self, PlatformAutoGen):
1387         BuildFile.__init__(self, PlatformAutoGen)
1388         self.ModuleBuildCommandList = []
1389         self.ModuleMakefileList = []
1390         self.IntermediateDirectoryList = []
1391         self.ModuleBuildDirectoryList = []
1392         self.LibraryBuildDirectoryList = []
1393         self.LibraryMakeCommandList = []
1394
1395     # Compose a dict object containing information used to do replacement in template
1396     @property
1397     def _TemplateDict(self):
1398         Separator = self._SEP_[self._FileType]
1399
1400         MyAgo = self._AutoGenObject
1401         if "MAKE" not in MyAgo.ToolDefinition or "PATH" not in MyAgo.ToolDefinition["MAKE"]:
1402             EdkLogger.error("build", OPTION_MISSING, "No MAKE command defined. Please check your tools_def.txt!",
1403                             ExtraData="[%s]" % str(MyAgo))
1404
1405         self.IntermediateDirectoryList = ["$(BUILD_DIR)"]
1406         self.ModuleBuildDirectoryList = self.GetModuleBuildDirectoryList()
1407         self.LibraryBuildDirectoryList = self.GetLibraryBuildDirectoryList()
1408
1409         MakefileName = self._FILE_NAME_[self._FileType]
1410         LibraryMakefileList = []
1411         LibraryMakeCommandList = []
1412         for D in self.LibraryBuildDirectoryList:
1413             D = self.PlaceMacro(D, {"BUILD_DIR":MyAgo.BuildDir})
1414             Makefile = os.path.join(D, MakefileName)
1415             Command = self._MAKE_TEMPLATE_[self._FileType] % {"file":Makefile}
1416             LibraryMakefileList.append(Makefile)
1417             LibraryMakeCommandList.append(Command)
1418         self.LibraryMakeCommandList = LibraryMakeCommandList
1419
1420         ModuleMakefileList = []
1421         ModuleMakeCommandList = []
1422         for D in self.ModuleBuildDirectoryList:
1423             D = self.PlaceMacro(D, {"BUILD_DIR":MyAgo.BuildDir})
1424             Makefile = os.path.join(D, MakefileName)
1425             Command = self._MAKE_TEMPLATE_[self._FileType] % {"file":Makefile}
1426             ModuleMakefileList.append(Makefile)
1427             ModuleMakeCommandList.append(Command)
1428
1429         MakefileTemplateDict = {
1430             "makefile_header"           : self._FILE_HEADER_[self._FileType],
1431             "makefile_path"             : os.path.join("$(BUILD_DIR)", MakefileName),
1432             "make_path"                 : MyAgo.ToolDefinition["MAKE"]["PATH"],
1433             "makefile_name"             : MakefileName,
1434             "platform_name"             : MyAgo.Name,
1435             "platform_guid"             : MyAgo.Guid,
1436             "platform_version"          : MyAgo.Version,
1437             "platform_file"             : MyAgo.MetaFile,
1438             "platform_relative_directory": MyAgo.SourceDir,
1439             "platform_output_directory" : MyAgo.OutputDir,
1440             "platform_build_directory"  : MyAgo.BuildDir,
1441             "platform_dir"              : MyAgo.Macros["PLATFORM_DIR"],
1442
1443             "toolchain_tag"             : MyAgo.ToolChain,
1444             "build_target"              : MyAgo.BuildTarget,
1445             "shell_command_code"        : self._SHELL_CMD_[self._FileType].keys(),
1446             "shell_command"             : self._SHELL_CMD_[self._FileType].values(),
1447             "build_architecture_list"   : MyAgo.Arch,
1448             "architecture"              : MyAgo.Arch,
1449             "separator"                 : Separator,
1450             "create_directory_command"  : self.GetCreateDirectoryCommand(self.IntermediateDirectoryList),
1451             "cleanall_command"          : self.GetRemoveDirectoryCommand(self.IntermediateDirectoryList),
1452             "library_makefile_list"     : LibraryMakefileList,
1453             "module_makefile_list"      : ModuleMakefileList,
1454             "library_build_command"     : LibraryMakeCommandList,
1455             "module_build_command"      : ModuleMakeCommandList,
1456         }
1457
1458         return MakefileTemplateDict
1459
1460     ## Get the root directory list for intermediate files of all modules build
1461     #
1462     #   @retval     list    The list of directory
1463     #
1464     def GetModuleBuildDirectoryList(self):
1465         DirList = []
1466         for ModuleAutoGen in self._AutoGenObject.ModuleAutoGenList:
1467             if not ModuleAutoGen.IsBinaryModule:
1468                 DirList.append(os.path.join(self._AutoGenObject.BuildDir, ModuleAutoGen.BuildDir))
1469         return DirList
1470
1471     ## Get the root directory list for intermediate files of all libraries build
1472     #
1473     #   @retval     list    The list of directory
1474     #
1475     def GetLibraryBuildDirectoryList(self):
1476         DirList = []
1477         for LibraryAutoGen in self._AutoGenObject.LibraryAutoGenList:
1478             if not LibraryAutoGen.IsBinaryModule:
1479                 DirList.append(os.path.join(self._AutoGenObject.BuildDir, LibraryAutoGen.BuildDir))
1480         return DirList
1481
1482 ## TopLevelMakefile class
1483 #
1484 #  This class encapsules makefie and its generation for entrance makefile. It
1485 # uses template to generate the content of makefile. The content of makefile
1486 # will be got from WorkspaceAutoGen object.
1487 #
1488 class TopLevelMakefile(BuildFile):
1489     ## template used to generate toplevel makefile
1490     _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}''')
1491
1492     ## Constructor of TopLevelMakefile
1493     #
1494     #   @param  Workspace   Object of WorkspaceAutoGen class
1495     #
1496     def __init__(self, Workspace):
1497         BuildFile.__init__(self, Workspace)
1498         self.IntermediateDirectoryList = []
1499
1500     # Compose a dict object containing information used to do replacement in template
1501     @property
1502     def _TemplateDict(self):
1503         Separator = self._SEP_[self._FileType]
1504
1505         # any platform autogen object is ok because we just need common information
1506         MyAgo = self._AutoGenObject
1507
1508         if "MAKE" not in MyAgo.ToolDefinition or "PATH" not in MyAgo.ToolDefinition["MAKE"]:
1509             EdkLogger.error("build", OPTION_MISSING, "No MAKE command defined. Please check your tools_def.txt!",
1510                             ExtraData="[%s]" % str(MyAgo))
1511
1512         for Arch in MyAgo.ArchList:
1513             self.IntermediateDirectoryList.append(Separator.join(["$(BUILD_DIR)", Arch]))
1514         self.IntermediateDirectoryList.append("$(FV_DIR)")
1515
1516         # TRICK: for not generating GenFds call in makefile if no FDF file
1517         MacroList = []
1518         if MyAgo.FdfFile is not None and MyAgo.FdfFile != "":
1519             FdfFileList = [MyAgo.FdfFile]
1520             # macros passed to GenFds
1521             MacroList.append('"%s=%s"' % ("EFI_SOURCE", GlobalData.gEfiSource.replace('\\', '\\\\')))
1522             MacroList.append('"%s=%s"' % ("EDK_SOURCE", GlobalData.gEdkSource.replace('\\', '\\\\')))
1523             MacroDict = {}
1524             MacroDict.update(GlobalData.gGlobalDefines)
1525             MacroDict.update(GlobalData.gCommandLineDefines)
1526             MacroDict.pop("EFI_SOURCE", "dummy")
1527             MacroDict.pop("EDK_SOURCE", "dummy")
1528             for MacroName in MacroDict:
1529                 if MacroDict[MacroName] != "":
1530                     MacroList.append('"%s=%s"' % (MacroName, MacroDict[MacroName].replace('\\', '\\\\')))
1531                 else:
1532                     MacroList.append('"%s"' % MacroName)
1533         else:
1534             FdfFileList = []
1535
1536         # pass extra common options to external program called in makefile, currently GenFds.exe
1537         ExtraOption = ''
1538         LogLevel = EdkLogger.GetLevel()
1539         if LogLevel == EdkLogger.VERBOSE:
1540             ExtraOption += " -v"
1541         elif LogLevel <= EdkLogger.DEBUG_9:
1542             ExtraOption += " -d %d" % (LogLevel - 1)
1543         elif LogLevel == EdkLogger.QUIET:
1544             ExtraOption += " -q"
1545
1546         if GlobalData.gCaseInsensitive:
1547             ExtraOption += " -c"
1548         if GlobalData.gEnableGenfdsMultiThread:
1549             ExtraOption += " --genfds-multi-thread"
1550         if GlobalData.gIgnoreSource:
1551             ExtraOption += " --ignore-sources"
1552
1553         for pcd in GlobalData.BuildOptionPcd:
1554             if pcd[2]:
1555                 pcdname = '.'.join(pcd[0:3])
1556             else:
1557                 pcdname = '.'.join(pcd[0:2])
1558             if pcd[3].startswith('{'):
1559                 ExtraOption += " --pcd " + pcdname + '=' + 'H' + '"' + pcd[3] + '"'
1560             else:
1561                 ExtraOption += " --pcd " + pcdname + '=' + pcd[3]
1562
1563         MakefileName = self._FILE_NAME_[self._FileType]
1564         SubBuildCommandList = []
1565         for A in MyAgo.ArchList:
1566             Command = self._MAKE_TEMPLATE_[self._FileType] % {"file":os.path.join("$(BUILD_DIR)", A, MakefileName)}
1567             SubBuildCommandList.append(Command)
1568
1569         MakefileTemplateDict = {
1570             "makefile_header"           : self._FILE_HEADER_[self._FileType],
1571             "makefile_path"             : os.path.join("$(BUILD_DIR)", MakefileName),
1572             "make_path"                 : MyAgo.ToolDefinition["MAKE"]["PATH"],
1573             "platform_name"             : MyAgo.Name,
1574             "platform_guid"             : MyAgo.Guid,
1575             "platform_version"          : MyAgo.Version,
1576             "platform_build_directory"  : MyAgo.BuildDir,
1577             "conf_directory"            : GlobalData.gConfDirectory,
1578
1579             "toolchain_tag"             : MyAgo.ToolChain,
1580             "build_target"              : MyAgo.BuildTarget,
1581             "shell_command_code"        : self._SHELL_CMD_[self._FileType].keys(),
1582             "shell_command"             : self._SHELL_CMD_[self._FileType].values(),
1583             'arch'                      : list(MyAgo.ArchList),
1584             "build_architecture_list"   : ','.join(MyAgo.ArchList),
1585             "separator"                 : Separator,
1586             "create_directory_command"  : self.GetCreateDirectoryCommand(self.IntermediateDirectoryList),
1587             "cleanall_command"          : self.GetRemoveDirectoryCommand(self.IntermediateDirectoryList),
1588             "sub_build_command"         : SubBuildCommandList,
1589             "fdf_file"                  : FdfFileList,
1590             "active_platform"           : str(MyAgo),
1591             "fd"                        : MyAgo.FdTargetList,
1592             "fv"                        : MyAgo.FvTargetList,
1593             "cap"                       : MyAgo.CapTargetList,
1594             "extra_options"             : ExtraOption,
1595             "macro"                     : MacroList,
1596         }
1597
1598         return MakefileTemplateDict
1599
1600     ## Get the root directory list for intermediate files of all modules build
1601     #
1602     #   @retval     list    The list of directory
1603     #
1604     def GetModuleBuildDirectoryList(self):
1605         DirList = []
1606         for ModuleAutoGen in self._AutoGenObject.ModuleAutoGenList:
1607             if not ModuleAutoGen.IsBinaryModule:
1608                 DirList.append(os.path.join(self._AutoGenObject.BuildDir, ModuleAutoGen.BuildDir))
1609         return DirList
1610
1611     ## Get the root directory list for intermediate files of all libraries build
1612     #
1613     #   @retval     list    The list of directory
1614     #
1615     def GetLibraryBuildDirectoryList(self):
1616         DirList = []
1617         for LibraryAutoGen in self._AutoGenObject.LibraryAutoGenList:
1618             if not LibraryAutoGen.IsBinaryModule:
1619                 DirList.append(os.path.join(self._AutoGenObject.BuildDir, LibraryAutoGen.BuildDir))
1620         return DirList
1621
1622 # This acts like the main() function for the script, unless it is 'import'ed into another script.
1623 if __name__ == '__main__':
1624     pass
1625