## @file\r
# Generate AutoGen.h, AutoGen.c and *.depex files\r
#\r
-# Copyright (c) 2007 - 2013, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>\r
# This program and the accompanying materials\r
# are licensed and made available under the terms and conditions of the BSD License\r
# which accompanies this distribution. The full text of the license may be found at\r
\r
## Import Modules\r
#\r
-import os\r
+import Common.LongFilePathOs as os\r
import re\r
import os.path as path\r
import copy\r
from StrGather import *\r
from BuildEngine import BuildRule\r
\r
+from Common.LongFilePathSupport import CopyLongFilePath\r
from Common.BuildToolError import *\r
from Common.DataType import *\r
from Common.Misc import *\r
GlobalData.gAutoGenPhase = True \r
Fdf = FdfParser(self.FdfFile.Path)\r
Fdf.ParseFile()\r
+ GlobalData.gFdfParser = Fdf\r
GlobalData.gAutoGenPhase = False\r
PcdSet = Fdf.Profile.PcdDict\r
ModuleList = Fdf.Profile.InfList\r
DecPcds = {}\r
DecPcdsKey = set()\r
PGen = PlatformAutoGen(self, self.MetaFile, Target, Toolchain, Arch)\r
- Pkgs = PGen.PackageList\r
+ PkgSet = set()\r
+ for Inf in ModuleList:\r
+ ModuleFile = PathClass(NormPath(Inf), GlobalData.gWorkspace, Arch)\r
+ if ModuleFile in Platform.Modules:\r
+ continue\r
+ ModuleData = self.BuildDatabase[ModuleFile, Arch, Target, Toolchain]\r
+ PkgSet.update(ModuleData.Packages)\r
+ Pkgs = list(PkgSet) + list(PGen.PackageList)\r
for Pkg in Pkgs:\r
for Pcd in Pkg.Pcds:\r
DecPcds[Pcd[0], Pcd[1]] = Pkg.Pcds[Pcd]\r
# Explicitly collect platform's dynamic PCDs\r
#\r
Pa.CollectPlatformDynamicPcds()\r
+ Pa.CollectFixedAtBuildPcds()\r
self.AutoGenObjectList.append(Pa)\r
\r
#\r
)\r
Count += 1\r
\r
+ def _GenFdsCommand(self):\r
+ return (GenMake.TopLevelMakefile(self)._TEMPLATE_.Replace(GenMake.TopLevelMakefile(self)._TemplateDict)).strip()\r
\r
## Create makefile for the platform and modules in it\r
#\r
# modules will be created as well\r
#\r
def CreateMakeFile(self, CreateDepsMakeFile=False):\r
- # create makefile for platform\r
- Makefile = GenMake.TopLevelMakefile(self)\r
- if Makefile.Generate():\r
- EdkLogger.debug(EdkLogger.DEBUG_9, "Generated makefile for platform [%s] %s\n" %\r
- (self.MetaFile, self.ArchList))\r
- else:\r
- EdkLogger.debug(EdkLogger.DEBUG_9, "Skipped the generation of makefile for platform [%s] %s\n" %\r
- (self.MetaFile, self.ArchList))\r
-\r
if CreateDepsMakeFile:\r
for Pa in self.AutoGenObjectList:\r
Pa.CreateMakeFile(CreateDepsMakeFile)\r
FvDir = property(_GetFvDir)\r
MakeFileDir = property(_GetMakeFileDir)\r
BuildCommand = property(_GetBuildCommand)\r
+ GenFdsCommand = property(_GenFdsCommand)\r
\r
## AutoGen class for platform\r
#\r
self.FdTargetList = self.Workspace.FdTargetList\r
self.FvTargetList = self.Workspace.FvTargetList\r
self.AllPcdList = []\r
+ # get the original module/package/platform objects\r
+ self.BuildDatabase = Workspace.BuildDatabase\r
\r
# flag indicating if the makefile/C-code file has been created or not\r
self.IsMakeFileCreated = False\r
self._PcdTokenNumber = None # (TokenCName, TokenSpaceGuidCName) : GeneratedTokenNumber\r
self._DynamicPcdList = None # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]\r
self._NonDynamicPcdList = None # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]\r
+ self._NonDynamicPcdDict = {}\r
\r
self._ToolDefinitions = None\r
self._ToolDefFile = None # toolcode : tool path\r
self._ModuleAutoGenList = None\r
self._LibraryAutoGenList = None\r
self._BuildCommand = None\r
-\r
+ self._AsBuildInfList = []\r
+ self._AsBuildModuleList = []\r
+ if GlobalData.gFdfParser != None:\r
+ self._AsBuildInfList = GlobalData.gFdfParser.Profile.InfList\r
+ for Inf in self._AsBuildInfList:\r
+ InfClass = PathClass(NormPath(Inf), GlobalData.gWorkspace, self.Arch)\r
+ M = self.BuildDatabase[InfClass, self.Arch, self.BuildTarget, self.ToolChain]\r
+ if not M.IsSupportedArch:\r
+ continue\r
+ self._AsBuildModuleList.append(InfClass)\r
+ # get library/modules for build\r
+ self.LibraryBuildDirectoryList = []\r
+ self.ModuleBuildDirectoryList = []\r
# get the original module/package/platform objects\r
- self.BuildDatabase = Workspace.BuildDatabase\r
+ self.LibraryBuildDirectoryList = []\r
+ self.ModuleBuildDirectoryList = []\r
return True\r
\r
def __repr__(self):\r
# don't do this twice\r
self.IsCodeFileCreated = True\r
\r
+ ## Generate Fds Command\r
+ def _GenFdsCommand(self):\r
+ return self.Workspace.GenFdsCommand\r
+ \r
## Create makefile for the platform and mdoules in it\r
#\r
# @param CreateModuleMakeFile Flag indicating if the makefile for\r
if self.IsMakeFileCreated:\r
return\r
\r
- # create makefile for platform\r
+ # create library/module build dirs for platform\r
Makefile = GenMake.PlatformMakefile(self)\r
- if Makefile.Generate():\r
- EdkLogger.debug(EdkLogger.DEBUG_9, "Generated makefile for platform [%s] [%s]\n" %\r
- (self.MetaFile, self.Arch))\r
- else:\r
- EdkLogger.debug(EdkLogger.DEBUG_9, "Skipped the generation of makefile for platform [%s] [%s]\n" %\r
- (self.MetaFile, self.Arch))\r
+ self.LibraryBuildDirectoryList = Makefile.GetLibraryBuildDirectoryList()\r
+ self.ModuleBuildDirectoryList = Makefile.GetModuleBuildDirectoryList()\r
+\r
self.IsMakeFileCreated = True\r
\r
+ ## Deal with Shared FixedAtBuild Pcds\r
+ #\r
+ def CollectFixedAtBuildPcds(self):\r
+ for LibAuto in self.LibraryAutoGenList:\r
+ FixedAtBuildPcds = {} \r
+ ShareFixedAtBuildPcdsSameValue = {} \r
+ for Module in LibAuto._ReferenceModules: \r
+ for Pcd in Module.FixedAtBuildPcds + LibAuto.FixedAtBuildPcds:\r
+ key = ".".join((Pcd.TokenSpaceGuidCName,Pcd.TokenCName)) \r
+ if key not in FixedAtBuildPcds:\r
+ ShareFixedAtBuildPcdsSameValue[key] = True\r
+ FixedAtBuildPcds[key] = Pcd.DefaultValue\r
+ else:\r
+ if FixedAtBuildPcds[key] != Pcd.DefaultValue:\r
+ ShareFixedAtBuildPcdsSameValue[key] = False \r
+ for Pcd in LibAuto.FixedAtBuildPcds:\r
+ key = ".".join((Pcd.TokenSpaceGuidCName,Pcd.TokenCName))\r
+ if (Pcd.TokenCName,Pcd.TokenSpaceGuidCName) not in self.NonDynamicPcdDict:\r
+ continue\r
+ else:\r
+ DscPcd = self.NonDynamicPcdDict[(Pcd.TokenCName,Pcd.TokenSpaceGuidCName)]\r
+ if DscPcd.Type != "FixedAtBuild":\r
+ continue\r
+ if key in ShareFixedAtBuildPcdsSameValue and ShareFixedAtBuildPcdsSameValue[key]: \r
+ LibAuto.ConstPcd[key] = Pcd.DefaultValue\r
+\r
## Collect dynamic PCDs\r
#\r
# Gather dynamic PCDs list from each module and their settings from platform\r
def CollectPlatformDynamicPcds(self):\r
# for gathering error information\r
NoDatumTypePcdList = set()\r
-\r
+ PcdNotInDb = []\r
self._GuidValue = {}\r
+ FdfModuleList = []\r
+ for InfName in self._AsBuildInfList:\r
+ InfName = os.path.join(self.WorkspaceDir, InfName)\r
+ FdfModuleList.append(os.path.normpath(InfName))\r
for F in self.Platform.Modules.keys():\r
M = ModuleAutoGen(self.Workspace, F, self.BuildTarget, self.ToolChain, self.Arch, self.MetaFile)\r
#GuidValue.update(M.Guids)\r
if PcdFromModule.DatumType == "VOID*" and PcdFromModule.MaxDatumSize in [None, '']:\r
NoDatumTypePcdList.add("%s.%s [%s]" % (PcdFromModule.TokenSpaceGuidCName, PcdFromModule.TokenCName, F))\r
\r
+ if M.IsBinaryModule == True:\r
+ PcdFromModule.IsFromBinaryInf = True\r
+ if (PcdFromModule.TokenCName, PcdFromModule.TokenSpaceGuidCName) in self.Platform.Pcds.keys():\r
+ PcdFromModule.IsFromDsc = True\r
+ else:\r
+ PcdFromModule.IsFromDsc = False\r
if PcdFromModule.Type in GenC.gDynamicPcd or PcdFromModule.Type in GenC.gDynamicExPcd:\r
+ if F.Path not in FdfModuleList:\r
+ # If one of the Source built modules listed in the DSC is not listed \r
+ # in FDF modules, and the INF lists a PCD can only use the PcdsDynamic \r
+ # access method (it is only listed in the DEC file that declares the \r
+ # PCD as PcdsDynamic), then build tool will report warning message\r
+ # notify the PI that they are attempting to build a module that must \r
+ # be included in a flash image in order to be functional. These Dynamic \r
+ # PCD will not be added into the Database unless it is used by other \r
+ # modules that are included in the FDF file.\r
+ if PcdFromModule.Type in GenC.gDynamicPcd and \\r
+ PcdFromModule.IsFromBinaryInf == False:\r
+ # Print warning message to let the developer make a determine.\r
+ if PcdFromModule not in PcdNotInDb:\r
+ EdkLogger.warn("build",\r
+ "A PCD listed in the DSC (%s.%s, %s) is used by a module not in the FDF. If the PCD is not used by any module listed in the FDF this PCD will be ignored. " \\r
+ % (PcdFromModule.TokenSpaceGuidCName, PcdFromModule.TokenCName, self.Platform.MetaFile.Path),\r
+ File=self.MetaFile, \\r
+ ExtraData=None)\r
+ PcdNotInDb.append(PcdFromModule)\r
+ continue\r
+ # If one of the Source built modules listed in the DSC is not listed in \r
+ # FDF modules, and the INF lists a PCD can only use the PcdsDynamicEx \r
+ # access method (it is only listed in the DEC file that declares the \r
+ # PCD as PcdsDynamicEx), then DO NOT break the build; DO NOT add the \r
+ # PCD to the Platform's PCD Database.\r
+ if PcdFromModule.Type in GenC.gDynamicExPcd:\r
+ if PcdFromModule not in PcdNotInDb:\r
+ PcdNotInDb.append(PcdFromModule)\r
+ continue\r
#\r
# If a dynamic PCD used by a PEM module/PEI module & DXE module,\r
# it should be stored in Pcd PEI database, If a dynamic only\r
self._DynaPcdList_[Index] = PcdFromModule\r
elif PcdFromModule not in self._NonDynaPcdList_:\r
self._NonDynaPcdList_.append(PcdFromModule)\r
+ elif PcdFromModule in self._NonDynaPcdList_ and PcdFromModule.IsFromBinaryInf == True:\r
+ Index = self._NonDynaPcdList_.index(PcdFromModule)\r
+ if self._NonDynaPcdList_[Index].IsFromBinaryInf == False:\r
+ #The PCD from Binary INF will override the same one from source INF\r
+ self._NonDynaPcdList_.remove (self._NonDynaPcdList_[Index])\r
+ PcdFromModule.Pending = False\r
+ self._NonDynaPcdList_.append (PcdFromModule)\r
+ # Parse the DynamicEx PCD from the AsBuild INF module list of FDF.\r
+ DscModuleList = []\r
+ for ModuleInf in self.Platform.Modules.keys():\r
+ DscModuleList.append (os.path.normpath(ModuleInf.Path))\r
+ # add the PCD from modules that listed in FDF but not in DSC to Database \r
+ for InfName in FdfModuleList:\r
+ if InfName not in DscModuleList:\r
+ InfClass = PathClass(InfName)\r
+ M = self.BuildDatabase[InfClass, self.Arch, self.BuildTarget, self.ToolChain]\r
+ # If a module INF in FDF but not in current arch's DSC module list, it must be module (either binary or source) \r
+ # for different Arch. PCDs in source module for different Arch is already added before, so skip the source module here. \r
+ # For binary module, if in current arch, we need to list the PCDs into database. \r
+ if not M.IsSupportedArch:\r
+ continue\r
+ # Override the module PCD setting by platform setting\r
+ ModulePcdList = self.ApplyPcdSetting(M, M.Pcds)\r
+ for PcdFromModule in ModulePcdList:\r
+ PcdFromModule.IsFromBinaryInf = True\r
+ PcdFromModule.IsFromDsc = False\r
+ # Only allow the DynamicEx and Patchable PCD in AsBuild INF\r
+ if PcdFromModule.Type not in GenC.gDynamicExPcd and PcdFromModule.Type not in TAB_PCDS_PATCHABLE_IN_MODULE:\r
+ EdkLogger.error("build", AUTOGEN_ERROR, "PCD setting error",\r
+ File=self.MetaFile,\r
+ ExtraData="\n\tExisted %s PCD %s in:\n\t\t%s\n"\r
+ % (PcdFromModule.Type, PcdFromModule.TokenCName, InfName))\r
+ # make sure that the "VOID*" kind of datum has MaxDatumSize set\r
+ if PcdFromModule.DatumType == "VOID*" and PcdFromModule.MaxDatumSize in [None, '']:\r
+ NoDatumTypePcdList.add("%s.%s [%s]" % (PcdFromModule.TokenSpaceGuidCName, PcdFromModule.TokenCName, InfName))\r
+ if M.ModuleType in ["PEIM", "PEI_CORE"]:\r
+ PcdFromModule.Phase = "PEI"\r
+ if PcdFromModule not in self._DynaPcdList_ and PcdFromModule.Type in GenC.gDynamicExPcd:\r
+ self._DynaPcdList_.append(PcdFromModule)\r
+ elif PcdFromModule not in self._NonDynaPcdList_ and PcdFromModule.Type in TAB_PCDS_PATCHABLE_IN_MODULE:\r
+ self._NonDynaPcdList_.append(PcdFromModule)\r
+ if PcdFromModule in self._DynaPcdList_ and PcdFromModule.Phase == 'PEI' and PcdFromModule.Type in GenC.gDynamicExPcd:\r
+ Index = self._DynaPcdList_.index(PcdFromModule)\r
+ self._DynaPcdList_[Index].Phase = PcdFromModule.Phase\r
+ self._DynaPcdList_[Index].Type = PcdFromModule.Type\r
+ for PcdFromModule in self._NonDynaPcdList_:\r
+ # If a PCD is not listed in the DSC file, but binary INF files used by \r
+ # this platform all (that use this PCD) list the PCD in a [PatchPcds] \r
+ # section, AND all source INF files used by this platform the build \r
+ # that use the PCD list the PCD in either a [Pcds] or [PatchPcds] \r
+ # section, then the tools must NOT add the PCD to the Platform's PCD\r
+ # Database; the build must assign the access method for this PCD as \r
+ # PcdsPatchableInModule.\r
+ if PcdFromModule not in self._DynaPcdList_:\r
+ continue\r
+ Index = self._DynaPcdList_.index(PcdFromModule)\r
+ if PcdFromModule.IsFromDsc == False and \\r
+ PcdFromModule.Type in TAB_PCDS_PATCHABLE_IN_MODULE and \\r
+ PcdFromModule.IsFromBinaryInf == True and \\r
+ self._DynaPcdList_[Index].IsFromBinaryInf == False:\r
+ Index = self._DynaPcdList_.index(PcdFromModule)\r
+ self._DynaPcdList_.remove (self._DynaPcdList_[Index])\r
\r
# print out error information and break the build, if error found\r
if len(NoDatumTypePcdList) > 0:\r
% NoDatumTypePcdListString)\r
self._NonDynamicPcdList = self._NonDynaPcdList_\r
self._DynamicPcdList = self._DynaPcdList_\r
- self.AllPcdList = self._NonDynamicPcdList + self._DynamicPcdList\r
- \r
+ # If PCD is listed in a PcdsDynamicHii, PcdsDynamicExHii, PcdsDynamicHii or PcdsDynamicExHii\r
+ # section, and the PCD is not used by any module that is listed in the DSC file, the build \r
+ # provide a warning message.\r
+ for PcdKey in self.Platform.Pcds.keys():\r
+ Pcd = self.Platform.Pcds[PcdKey]\r
+ if Pcd not in self._DynamicPcdList + PcdNotInDb and \\r
+ Pcd.Type in [TAB_PCDS_DYNAMIC, TAB_PCDS_DYNAMIC_DEFAULT, TAB_PCDS_DYNAMIC_HII, TAB_PCDS_DYNAMIC_EX, TAB_PCDS_DYNAMIC_EX_DEFAULT, TAB_PCDS_DYNAMIC_EX_HII]:\r
+ # Print warning message to let the developer make a determine.\r
+ EdkLogger.warn("build",\r
+ "A %s PCD listed in the DSC (%s.%s, %s) is not used by any module." \\r
+ % (Pcd.Type, Pcd.TokenSpaceGuidCName, Pcd.TokenCName, self.Platform.MetaFile.Path),\r
+ File=self.MetaFile, \\r
+ ExtraData=None)\r
#\r
# Sort dynamic PCD list to:\r
# 1) If PCD's datum type is VOID* and value is unicode string which starts with L, the PCD item should \r
self._DynamicPcdList.extend(UnicodePcdArray)\r
self._DynamicPcdList.extend(HiiPcdArray)\r
self._DynamicPcdList.extend(OtherPcdArray)\r
- \r
+ self.AllPcdList = self._NonDynamicPcdList + self._DynamicPcdList\r
\r
## Return the platform build data object\r
def _GetPlatform(self):\r
self._PackageList.update(La.DependentPackageList)\r
for Ma in self.ModuleAutoGenList:\r
self._PackageList.update(Ma.DependentPackageList)\r
- self._PackageList = list(self._PackageList)\r
+ #Collect package set information from INF of FDF\r
+ PkgSet = set()\r
+ for ModuleFile in self._AsBuildModuleList:\r
+ if ModuleFile in self.Platform.Modules:\r
+ continue\r
+ ModuleData = self.BuildDatabase[ModuleFile, self.Arch, self.BuildTarget, self.ToolChain]\r
+ PkgSet.update(ModuleData.Packages)\r
+ self._PackageList = list(self._PackageList) + list (PkgSet)\r
return self._PackageList\r
\r
+ def _GetNonDynamicPcdDict(self):\r
+ if self._NonDynamicPcdDict:\r
+ return self._NonDynamicPcdDict\r
+ for Pcd in self.NonDynamicPcdList:\r
+ self._NonDynamicPcdDict[(Pcd.TokenCName,Pcd.TokenSpaceGuidCName)] = Pcd\r
+ return self._NonDynamicPcdDict\r
+\r
## Get list of non-dynamic PCDs\r
def _GetNonDynamicPcdList(self):\r
if self._NonDynamicPcdList == None:\r
for La in Ma.LibraryAutoGenList:\r
if La not in self._LibraryAutoGenList:\r
self._LibraryAutoGenList.append(La)\r
+ if Ma not in La._ReferenceModules:\r
+ La._ReferenceModules.append(Ma)\r
\r
## Summarize ModuleAutoGen objects of all modules to be built for this platform\r
def _GetModuleAutoGenList(self):\r
# by the platform or current configuration\r
#\r
def ValidModule(self, Module):\r
- return Module in self.Platform.Modules or Module in self.Platform.LibraryInstances\r
+ return Module in self.Platform.Modules or Module in self.Platform.LibraryInstances \\r
+ or Module in self._AsBuildModuleList\r
\r
## Resolve the library classes in a module to library instances\r
#\r
PcdTokenNumber = property(_GetPcdTokenNumbers) # (TokenCName, TokenSpaceGuidCName) : GeneratedTokenNumber\r
DynamicPcdList = property(_GetDynamicPcdList) # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]\r
NonDynamicPcdList = property(_GetNonDynamicPcdList) # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]\r
+ NonDynamicPcdDict = property(_GetNonDynamicPcdDict)\r
PackageList = property(_GetPackageList)\r
\r
ToolDefinition = property(_GetToolDefinition) # toolcode : tool path\r
BuildRule = property(_GetBuildRule)\r
ModuleAutoGenList = property(_GetModuleAutoGenList)\r
LibraryAutoGenList = property(_GetLibraryAutoGenList)\r
+ GenFdsCommand = property(_GenFdsCommand)\r
\r
## ModuleAutoGen class\r
#\r
self._FinalBuildTargetList = None\r
self._FileTypes = None\r
self._BuildRules = None\r
-\r
+ \r
+ ## The Modules referenced to this Library\r
+ # Only Library has this attribute\r
+ self._ReferenceModules = [] \r
+ \r
+ ## Store the FixedAtBuild Pcds\r
+ # \r
+ self._FixedAtBuildPcds = []\r
+ self.ConstPcd = {}\r
return True\r
\r
def __repr__(self):\r
return "%s [%s]" % (self.MetaFile, self.Arch)\r
\r
+ # Get FixedAtBuild Pcds of this Module\r
+ def _GetFixedAtBuildPcds(self):\r
+ if self._FixedAtBuildPcds:\r
+ return self._FixedAtBuildPcds\r
+ for Pcd in self.ModulePcdList:\r
+ if self.IsLibrary:\r
+ if not (Pcd.Pending == False and Pcd.Type == "FixedAtBuild"):\r
+ continue\r
+ elif Pcd.Type != "FixedAtBuild":\r
+ continue\r
+ if Pcd not in self._FixedAtBuildPcds:\r
+ self._FixedAtBuildPcds.append(Pcd)\r
+ \r
+ return self._FixedAtBuildPcds \r
+\r
# Macros could be used in build_rule.txt (also Makefile)\r
def _GetMacros(self):\r
if self._Macro == None:\r
self._BuildTargets = {}\r
self._FileTypes = {}\r
\r
+ SubDirectory = os.path.join(self.OutputDir, File.SubDir)\r
+ if not os.path.exists(SubDirectory):\r
+ CreateDirectory(SubDirectory)\r
LastTarget = None\r
RuleChain = []\r
SourceList = [File]\r
AutoGenH = TemplateString()\r
StringH = TemplateString()\r
GenC.CreateCode(self, AutoGenC, AutoGenH, StringH, UniStringAutoGenC, UniStringBinBuffer)\r
- if str(AutoGenC) != "" and TAB_C_CODE_FILE in self.FileTypes:\r
+ #\r
+ # AutoGen.c is generated if there are library classes in inf, or there are object files\r
+ #\r
+ if str(AutoGenC) != "" and (len(self.Module.LibraryClasses) > 0\r
+ or TAB_OBJECT_FILE in self.FileTypes):\r
AutoFile = PathClass(gAutoGenCodeFileName, self.DebugDir)\r
self._AutoGenFileList[AutoFile] = str(AutoGenC)\r
self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)\r
# dependent libraries will be created\r
#\r
def CreateMakeFile(self, CreateLibraryMakeFile=True):\r
+ # Ignore generating makefile when it is a binary module\r
+ if self.IsBinaryModule:\r
+ return\r
+\r
if self.IsMakeFileCreated:\r
return\r
\r
\r
self.IsMakeFileCreated = True\r
\r
+ def CopyBinaryFiles(self):\r
+ for File in self.Module.Binaries:\r
+ SrcPath = File.Path\r
+ DstPath = os.path.join(self.OutputDir , os.path.basename(SrcPath))\r
+ CopyLongFilePath(SrcPath, DstPath)\r
## Create autogen code for the module and its dependent libraries\r
#\r
# @param CreateLibraryCodeFile Flag indicating if or not the code of\r
if self.IsBinaryModule and self.PcdIsDriver != '':\r
CreatePcdDatabaseCode(self, TemplateString(), TemplateString())\r
return\r
+ if self.IsBinaryModule:\r
+ self.CopyBinaryFiles()\r
+ return\r
\r
if not self.IsLibrary and CreateLibraryCodeFile:\r
for LibraryAutoGen in self.LibraryAutoGenList:\r
BuildOption = property(_GetModuleBuildOption)\r
BuildOptionIncPathList = property(_GetBuildOptionIncPathList)\r
BuildCommand = property(_GetBuildCommand)\r
+ \r
+ FixedAtBuildPcds = property(_GetFixedAtBuildPcds)\r
\r
# This acts like the main() function for the script, unless it is 'import'ed into another script.\r
if __name__ == '__main__':\r
projects / mirror_edk2.git / blobdiff