BaseTools/Source/Python/AutoGen/GenMake.py

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