\r
## Import Modules\r
#\r
+from __future__ import print_function\r
import Common.LongFilePathOs as os\r
import re\r
import os.path as path\r
import GenC\r
import GenMake\r
import GenDepex\r
-from StringIO import StringIO\r
+from io import BytesIO\r
\r
from StrGather import *\r
from BuildEngine import BuildRule\r
import Common.VpdInfoFile as VpdInfoFile\r
from GenPcdDb import CreatePcdDatabaseCode\r
from Workspace.MetaFileCommentParser import UsageList\r
+from Workspace.WorkspaceCommon import GetModuleLibInstances\r
from Common.MultipleWorkspace import MultipleWorkspace as mws\r
import InfSectionParser\r
import datetime\r
import hashlib\r
-from GenVar import VariableMgr,var_info\r
+from GenVar import VariableMgr, var_info\r
from collections import OrderedDict\r
from collections import defaultdict\r
+from Workspace.WorkspaceCommon import OrderedListDict\r
\r
## Regular expression for splitting Dependency Expression string into tokens\r
gDepexTokenPattern = re.compile("(\(|\)|\w+| \S+\.inf)")\r
'build',\r
FORMAT_INVALID,\r
"Building modules from source INFs, following PCD use %s and %s access method. It must be corrected to use only one access method." % (i, j),\r
- ExtraData="%s" % '\n\t'.join(str(P[1]+'.'+P[0]) for P in Intersections)\r
+ ExtraData='\n\t'.join(str(P[1]+'.'+P[0]) for P in Intersections)\r
)\r
\r
#\r
os.makedirs(self.BuildDir)\r
with open(os.path.join(self.BuildDir, 'AutoGen'), 'w+') as file:\r
for f in AllWorkSpaceMetaFiles:\r
- print >> file, f\r
+ print(f, file=file)\r
return True\r
\r
def _GenPkgLevelHash(self, Pkg):\r
#\r
if self.FdfFile:\r
AllWorkSpaceMetaFiles.add (self.FdfFile.Path)\r
- if self.FdfFile:\r
- FdfFiles = GlobalData.gFdfParser.GetAllIncludedFile()\r
- for f in FdfFiles:\r
- AllWorkSpaceMetaFiles.add (f.FileName)\r
+ for f in GlobalData.gFdfParser.GetAllIncludedFile():\r
+ AllWorkSpaceMetaFiles.add (f.FileName)\r
#\r
# add dsc\r
#\r
AllWorkSpaceMetaFiles.add(os.path.join(self.BuildDir, 'PcdTokenNumber'))\r
\r
for Arch in self.ArchList:\r
- Platform = self.BuildDatabase[self.MetaFile, Arch, Target, Toolchain]\r
- PGen = PlatformAutoGen(self, self.MetaFile, Target, Toolchain, Arch)\r
-\r
#\r
# add dec\r
#\r
- for Package in PGen.PackageList:\r
+ for Package in PlatformAutoGen(self, self.MetaFile, Target, Toolchain, Arch).PackageList:\r
AllWorkSpaceMetaFiles.add(Package.MetaFile.Path)\r
\r
#\r
# add included dsc\r
#\r
- for filePath in Platform._RawData.IncludedFiles:\r
+ for filePath in self.BuildDatabase[self.MetaFile, Arch, Target, Toolchain]._RawData.IncludedFiles:\r
AllWorkSpaceMetaFiles.add(filePath.Path)\r
\r
return AllWorkSpaceMetaFiles\r
\r
\r
def _CheckPcdDefineAndType(self):\r
- PcdTypeList = [\r
- TAB_PCDS_FIXED_AT_BUILD, TAB_PCDS_PATCHABLE_IN_MODULE, TAB_PCDS_FEATURE_FLAG,\r
- TAB_PCDS_DYNAMIC, #TAB_PCDS_DYNAMIC_HII, TAB_PCDS_DYNAMIC_VPD,\r
- TAB_PCDS_DYNAMIC_EX, # TAB_PCDS_DYNAMIC_EX_HII, TAB_PCDS_DYNAMIC_EX_VPD\r
- ]\r
+ PcdTypeSet = {TAB_PCDS_FIXED_AT_BUILD,\r
+ TAB_PCDS_PATCHABLE_IN_MODULE,\r
+ TAB_PCDS_FEATURE_FLAG,\r
+ TAB_PCDS_DYNAMIC,\r
+ TAB_PCDS_DYNAMIC_EX}\r
\r
# This dict store PCDs which are not used by any modules with specified arches\r
UnusedPcd = OrderedDict()\r
# Key of DEC's Pcds dictionary is PcdCName, TokenSpaceGuid, PcdType\r
if (Pcd[0], Pcd[1], PcdType) in Package.Pcds:\r
break\r
- for Type in PcdTypeList:\r
+ for Type in PcdTypeSet:\r
if (Pcd[0], Pcd[1], Type) in Package.Pcds:\r
EdkLogger.error(\r
'build',\r
# modules will be created as well\r
#\r
def CreateMakeFile(self, CreateDepsMakeFile=False):\r
- if CreateDepsMakeFile:\r
- for Pa in self.AutoGenObjectList:\r
- Pa.CreateMakeFile(CreateDepsMakeFile)\r
+ if not CreateDepsMakeFile:\r
+ return\r
+ for Pa in self.AutoGenObjectList:\r
+ Pa.CreateMakeFile(True)\r
\r
## Create autogen code for platform and modules\r
#\r
if not CreateDepsCodeFile:\r
return\r
for Pa in self.AutoGenObjectList:\r
- Pa.CreateCodeFile(CreateDepsCodeFile)\r
+ Pa.CreateCodeFile(True)\r
\r
## Create AsBuilt INF file the platform\r
#\r
ShareFixedAtBuildPcdsSameValue = {} \r
for Module in LibAuto._ReferenceModules: \r
for Pcd in Module.FixedAtBuildPcds + LibAuto.FixedAtBuildPcds:\r
- key = ".".join((Pcd.TokenSpaceGuidCName,Pcd.TokenCName)) \r
+ key = ".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName))\r
if key not in FixedAtBuildPcds:\r
ShareFixedAtBuildPcdsSameValue[key] = True\r
FixedAtBuildPcds[key] = Pcd.DefaultValue\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
+ 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
+ DscPcd = self.NonDynamicPcdDict[(Pcd.TokenCName, Pcd.TokenSpaceGuidCName)]\r
if DscPcd.Type != TAB_PCDS_FIXED_AT_BUILD:\r
continue\r
if key in ShareFixedAtBuildPcdsSameValue and ShareFixedAtBuildPcdsSameValue[key]: \r
break\r
\r
\r
- VariableInfo = VariableMgr(self.DscBuildDataObj._GetDefaultStores(),self.DscBuildDataObj._GetSkuIds())\r
+ VariableInfo = VariableMgr(self.DscBuildDataObj._GetDefaultStores(), self.DscBuildDataObj._GetSkuIds())\r
VariableInfo.SetVpdRegionMaxSize(VpdRegionSize)\r
VariableInfo.SetVpdRegionOffset(VpdRegionBase)\r
Index = 0\r
for Pcd in DynamicPcdSet:\r
- pcdname = ".".join((Pcd.TokenSpaceGuidCName,Pcd.TokenCName))\r
+ pcdname = ".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName))\r
for SkuName in Pcd.SkuInfoList:\r
Sku = Pcd.SkuInfoList[SkuName]\r
SkuId = Sku.SkuId\r
VariableGuidStructure = Sku.VariableGuidValue\r
VariableGuid = GuidStructureStringToGuidString(VariableGuidStructure)\r
for StorageName in Sku.DefaultStoreDict:\r
- VariableInfo.append_variable(var_info(Index,pcdname,StorageName,SkuName, StringToArray(Sku.VariableName),VariableGuid, Sku.VariableOffset, Sku.VariableAttribute , Sku.HiiDefaultValue,Sku.DefaultStoreDict[StorageName],Pcd.DatumType))\r
+ VariableInfo.append_variable(var_info(Index, pcdname, StorageName, SkuName, StringToArray(Sku.VariableName), VariableGuid, Sku.VariableOffset, Sku.VariableAttribute, Sku.HiiDefaultValue, Sku.DefaultStoreDict[StorageName], Pcd.DatumType))\r
Index += 1\r
return VariableInfo\r
\r
- def UpdateNVStoreMaxSize(self,OrgVpdFile):\r
+ def UpdateNVStoreMaxSize(self, OrgVpdFile):\r
if self.VariableInfo:\r
VpdMapFilePath = os.path.join(self.BuildDir, TAB_FV_DIRECTORY, "%s.map" % self.Platform.VpdToolGuid)\r
PcdNvStoreDfBuffer = [item for item in self._DynamicPcdList if item.TokenCName == "PcdNvStoreDefaultValueBuffer" and item.TokenSpaceGuidCName == "gEfiMdeModulePkgTokenSpaceGuid"]\r
else:\r
EdkLogger.error("build", FILE_READ_FAILURE, "Can not find VPD map file %s to fix up VPD offset." % VpdMapFilePath)\r
\r
- NvStoreOffset = int(NvStoreOffset,16) if NvStoreOffset.upper().startswith("0X") else int(NvStoreOffset)\r
+ NvStoreOffset = int(NvStoreOffset, 16) if NvStoreOffset.upper().startswith("0X") else int(NvStoreOffset)\r
default_skuobj = PcdNvStoreDfBuffer[0].SkuInfoList.get(TAB_DEFAULT)\r
maxsize = self.VariableInfo.VpdRegionSize - NvStoreOffset if self.VariableInfo.VpdRegionSize else len(default_skuobj.DefaultValue.split(","))\r
var_data = self.VariableInfo.PatchNVStoreDefaultMaxSize(maxsize)\r
del self.Platform.Pcds[key]\r
self.Platform.Pcds[newkey] = Value\r
break\r
- else:\r
- pass\r
break\r
- else:\r
- pass\r
\r
# for gathering error information\r
NoDatumTypePcdList = set()\r
VpdPcdDict[(Pcd.TokenCName, Pcd.TokenSpaceGuidCName)] = Pcd\r
\r
#Collect DynamicHii PCD values and assign it to DynamicExVpd PCD gEfiMdeModulePkgTokenSpaceGuid.PcdNvStoreDefaultValueBuffer\r
- PcdNvStoreDfBuffer = VpdPcdDict.get(("PcdNvStoreDefaultValueBuffer","gEfiMdeModulePkgTokenSpaceGuid"))\r
+ PcdNvStoreDfBuffer = VpdPcdDict.get(("PcdNvStoreDefaultValueBuffer", "gEfiMdeModulePkgTokenSpaceGuid"))\r
if PcdNvStoreDfBuffer:\r
self.VariableInfo = self.CollectVariables(self._DynamicPcdList)\r
vardump = self.VariableInfo.dump()\r
PcdNvStoreDfBuffer.SkuInfoList[skuname].DefaultValue = vardump\r
PcdNvStoreDfBuffer.MaxDatumSize = str(len(vardump.split(",")))\r
\r
- PlatformPcds = self._PlatformPcds.keys()\r
- PlatformPcds.sort()\r
+ PlatformPcds = sorted(self._PlatformPcds.keys())\r
#\r
# Add VPD type PCD into VpdFile and determine whether the VPD PCD need to be fixed up.\r
#\r
PcdValue = DefaultSku.DefaultValue\r
if PcdValue not in SkuValueMap:\r
SkuValueMap[PcdValue] = []\r
- VpdFile.Add(Pcd, TAB_DEFAULT,DefaultSku.VpdOffset)\r
+ VpdFile.Add(Pcd, TAB_DEFAULT, DefaultSku.VpdOffset)\r
SkuValueMap[PcdValue].append(DefaultSku)\r
\r
- for (SkuName,Sku) in Pcd.SkuInfoList.items():\r
+ for (SkuName, Sku) in Pcd.SkuInfoList.items():\r
Sku.VpdOffset = Sku.VpdOffset.strip()\r
PcdValue = Sku.DefaultValue\r
if PcdValue == "":\r
EdkLogger.error("build", FORMAT_INVALID, 'The offset value of PCD %s.%s should be %s-byte aligned.' % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, Alignment))\r
if PcdValue not in SkuValueMap:\r
SkuValueMap[PcdValue] = []\r
- VpdFile.Add(Pcd, SkuName,Sku.VpdOffset)\r
+ VpdFile.Add(Pcd, SkuName, Sku.VpdOffset)\r
SkuValueMap[PcdValue].append(Sku)\r
# if the offset of a VPD is *, then it need to be fixed up by third party tool.\r
if not NeedProcessVpdMapFile and Sku.VpdOffset == "*":\r
SkuObjList = DscPcdEntry.SkuInfoList.items()\r
DefaultSku = DscPcdEntry.SkuInfoList.get(TAB_DEFAULT)\r
if DefaultSku:\r
- defaultindex = SkuObjList.index((TAB_DEFAULT,DefaultSku))\r
- SkuObjList[0],SkuObjList[defaultindex] = SkuObjList[defaultindex],SkuObjList[0]\r
- for (SkuName,Sku) in SkuObjList:\r
+ defaultindex = SkuObjList.index((TAB_DEFAULT, DefaultSku))\r
+ SkuObjList[0], SkuObjList[defaultindex] = SkuObjList[defaultindex], SkuObjList[0]\r
+ for (SkuName, Sku) in SkuObjList:\r
Sku.VpdOffset = Sku.VpdOffset.strip() \r
\r
# Need to iterate DEC pcd information to get the value & datumtype\r
EdkLogger.error("build", FORMAT_INVALID, 'The offset value of PCD %s.%s should be %s-byte aligned.' % (DscPcdEntry.TokenSpaceGuidCName, DscPcdEntry.TokenCName, Alignment))\r
if PcdValue not in SkuValueMap:\r
SkuValueMap[PcdValue] = []\r
- VpdFile.Add(DscPcdEntry, SkuName,Sku.VpdOffset)\r
+ VpdFile.Add(DscPcdEntry, SkuName, Sku.VpdOffset)\r
SkuValueMap[PcdValue].append(Sku)\r
if not NeedProcessVpdMapFile and Sku.VpdOffset == "*":\r
NeedProcessVpdMapFile = True \r
self._DynamicPcdList.extend(list(UnicodePcdArray))\r
self._DynamicPcdList.extend(list(HiiPcdArray))\r
self._DynamicPcdList.extend(list(OtherPcdArray))\r
- allskuset = [(SkuName,Sku.SkuId) for pcd in self._DynamicPcdList for (SkuName,Sku) in pcd.SkuInfoList.items()]\r
+ allskuset = [(SkuName, Sku.SkuId) for pcd in self._DynamicPcdList for (SkuName, Sku) in pcd.SkuInfoList.items()]\r
for pcd in self._DynamicPcdList:\r
if len(pcd.SkuInfoList) == 1:\r
- for (SkuName,SkuId) in allskuset:\r
- if type(SkuId) in (str,unicode) and eval(SkuId) == 0 or SkuId == 0:\r
+ for (SkuName, SkuId) in allskuset:\r
+ if type(SkuId) in (str, unicode) and eval(SkuId) == 0 or SkuId == 0:\r
continue\r
pcd.SkuInfoList[SkuName] = copy.deepcopy(pcd.SkuInfoList[TAB_DEFAULT])\r
pcd.SkuInfoList[SkuName].SkuId = SkuId\r
self.AllPcdList = self._NonDynamicPcdList + self._DynamicPcdList\r
\r
- def FixVpdOffset(self,VpdFile ):\r
+ def FixVpdOffset(self, VpdFile ):\r
FvPath = os.path.join(self.BuildDir, TAB_FV_DIRECTORY)\r
if not os.path.exists(FvPath):\r
try:\r
# retrieve BPDG tool's path from tool_def.txt according to VPD_TOOL_GUID defined in DSC file.\r
BPDGToolName = None\r
for ToolDef in self.ToolDefinition.values():\r
- if ToolDef.has_key(TAB_GUID) and ToolDef[TAB_GUID] == self.Platform.VpdToolGuid:\r
- if not ToolDef.has_key("PATH"):\r
+ if TAB_GUID in ToolDef and ToolDef[TAB_GUID] == self.Platform.VpdToolGuid:\r
+ if "PATH" not in ToolDef:\r
EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, "PATH attribute was not provided for BPDG guid tool %s in tools_def.txt" % self.Platform.VpdToolGuid)\r
BPDGToolName = ToolDef["PATH"]\r
break\r
if Flags.startswith('='):\r
self._BuildCommand = [self._BuildCommand[0]] + [Flags[1:]]\r
else:\r
- self._BuildCommand += [Flags]\r
+ self._BuildCommand.append(Flags)\r
return self._BuildCommand\r
\r
## Get tool chain definition\r
if self._NonDynamicPcdDict:\r
return self._NonDynamicPcdDict\r
for Pcd in self.NonDynamicPcdList:\r
- self._NonDynamicPcdDict[(Pcd.TokenCName,Pcd.TokenSpaceGuidCName)] = Pcd\r
+ self._NonDynamicPcdDict[(Pcd.TokenCName, Pcd.TokenSpaceGuidCName)] = Pcd\r
return self._NonDynamicPcdDict\r
\r
## Get list of non-dynamic PCDs\r
# TokeNumber 11 ~ 20\r
#\r
for Pcd in self.DynamicPcdList:\r
- if Pcd.Phase == "PEI":\r
- if Pcd.Type in PCD_DYNAMIC_TYPE_SET:\r
- EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))\r
- self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber\r
- TokenNumber += 1\r
+ if Pcd.Phase == "PEI" and Pcd.Type in PCD_DYNAMIC_TYPE_SET:\r
+ EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))\r
+ self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber\r
+ TokenNumber += 1\r
\r
for Pcd in self.DynamicPcdList:\r
- if Pcd.Phase == "PEI":\r
- if Pcd.Type in PCD_DYNAMIC_EX_TYPE_SET:\r
- EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))\r
- self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber\r
- TokenNumber += 1\r
+ if Pcd.Phase == "PEI" and Pcd.Type in PCD_DYNAMIC_EX_TYPE_SET:\r
+ EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))\r
+ self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber\r
+ TokenNumber += 1\r
\r
for Pcd in self.DynamicPcdList:\r
- if Pcd.Phase == "DXE":\r
- if Pcd.Type in PCD_DYNAMIC_TYPE_SET:\r
- EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))\r
- self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber\r
- TokenNumber += 1\r
+ if Pcd.Phase == "DXE" and Pcd.Type in PCD_DYNAMIC_TYPE_SET:\r
+ EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))\r
+ self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber\r
+ TokenNumber += 1\r
\r
for Pcd in self.DynamicPcdList:\r
- if Pcd.Phase == "DXE":\r
- if Pcd.Type in PCD_DYNAMIC_EX_TYPE_SET:\r
- EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))\r
- self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber\r
- TokenNumber += 1\r
+ if Pcd.Phase == "DXE" and Pcd.Type in PCD_DYNAMIC_EX_TYPE_SET:\r
+ EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))\r
+ self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber\r
+ TokenNumber += 1\r
\r
for Pcd in self.NonDynamicPcdList:\r
self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber\r
if str(Module) not in self.Platform.Modules:\r
return []\r
\r
- ModuleType = Module.ModuleType\r
-\r
- # for overridding library instances with module specific setting\r
- PlatformModule = self.Platform.Modules[str(Module)]\r
-\r
- # add forced library instances (specified under LibraryClasses sections)\r
- #\r
- # If a module has a MODULE_TYPE of USER_DEFINED,\r
- # do not link in NULL library class instances from the global [LibraryClasses.*] sections.\r
- #\r
- if Module.ModuleType != SUP_MODULE_USER_DEFINED:\r
- for LibraryClass in self.Platform.LibraryClasses.GetKeys():\r
- if LibraryClass.startswith("NULL") and self.Platform.LibraryClasses[LibraryClass, Module.ModuleType]:\r
- Module.LibraryClasses[LibraryClass] = self.Platform.LibraryClasses[LibraryClass, Module.ModuleType]\r
-\r
- # add forced library instances (specified in module overrides)\r
- for LibraryClass in PlatformModule.LibraryClasses:\r
- if LibraryClass.startswith("NULL"):\r
- Module.LibraryClasses[LibraryClass] = PlatformModule.LibraryClasses[LibraryClass]\r
-\r
- # EdkII module\r
- LibraryConsumerList = [Module]\r
- Constructor = []\r
- ConsumedByList = OrderedDict()\r
- LibraryInstance = OrderedDict()\r
-\r
- EdkLogger.verbose("")\r
- EdkLogger.verbose("Library instances of module [%s] [%s]:" % (str(Module), self.Arch))\r
- while len(LibraryConsumerList) > 0:\r
- M = LibraryConsumerList.pop()\r
- for LibraryClassName in M.LibraryClasses:\r
- if LibraryClassName not in LibraryInstance:\r
- # override library instance for this module\r
- if LibraryClassName in PlatformModule.LibraryClasses:\r
- LibraryPath = PlatformModule.LibraryClasses[LibraryClassName]\r
- else:\r
- LibraryPath = self.Platform.LibraryClasses[LibraryClassName, ModuleType]\r
- if LibraryPath is None or LibraryPath == "":\r
- LibraryPath = M.LibraryClasses[LibraryClassName]\r
- if LibraryPath is None or LibraryPath == "":\r
- EdkLogger.error("build", RESOURCE_NOT_AVAILABLE,\r
- "Instance of library class [%s] is not found" % LibraryClassName,\r
- File=self.MetaFile,\r
- ExtraData="in [%s] [%s]\n\tconsumed by module [%s]" % (str(M), self.Arch, str(Module)))\r
-\r
- LibraryModule = self.BuildDatabase[LibraryPath, self.Arch, self.BuildTarget, self.ToolChain]\r
- # for those forced library instance (NULL library), add a fake library class\r
- if LibraryClassName.startswith("NULL"):\r
- LibraryModule.LibraryClass.append(LibraryClassObject(LibraryClassName, [ModuleType]))\r
- elif LibraryModule.LibraryClass is None \\r
- or len(LibraryModule.LibraryClass) == 0 \\r
- or (ModuleType != SUP_MODULE_USER_DEFINED\r
- and ModuleType not in LibraryModule.LibraryClass[0].SupModList):\r
- # only USER_DEFINED can link against any library instance despite of its SupModList\r
- EdkLogger.error("build", OPTION_MISSING,\r
- "Module type [%s] is not supported by library instance [%s]" \\r
- % (ModuleType, LibraryPath), File=self.MetaFile,\r
- ExtraData="consumed by [%s]" % str(Module))\r
-\r
- LibraryInstance[LibraryClassName] = LibraryModule\r
- LibraryConsumerList.append(LibraryModule)\r
- EdkLogger.verbose("\t" + str(LibraryClassName) + " : " + str(LibraryModule))\r
- else:\r
- LibraryModule = LibraryInstance[LibraryClassName]\r
-\r
- if LibraryModule is None:\r
- continue\r
-\r
- if LibraryModule.ConstructorList != [] and LibraryModule not in Constructor:\r
- Constructor.append(LibraryModule)\r
-\r
- if LibraryModule not in ConsumedByList:\r
- ConsumedByList[LibraryModule] = []\r
- # don't add current module itself to consumer list\r
- if M != Module:\r
- if M in ConsumedByList[LibraryModule]:\r
- continue\r
- ConsumedByList[LibraryModule].append(M)\r
- #\r
- # Initialize the sorted output list to the empty set\r
- #\r
- SortedLibraryList = []\r
- #\r
- # Q <- Set of all nodes with no incoming edges\r
- #\r
- LibraryList = [] #LibraryInstance.values()\r
- Q = []\r
- for LibraryClassName in LibraryInstance:\r
- M = LibraryInstance[LibraryClassName]\r
- LibraryList.append(M)\r
- if ConsumedByList[M] == []:\r
- Q.append(M)\r
-\r
- #\r
- # start the DAG algorithm\r
- #\r
- while True:\r
- EdgeRemoved = True\r
- while Q == [] and EdgeRemoved:\r
- EdgeRemoved = False\r
- # for each node Item with a Constructor\r
- for Item in LibraryList:\r
- if Item not in Constructor:\r
- continue\r
- # for each Node without a constructor with an edge e from Item to Node\r
- for Node in ConsumedByList[Item]:\r
- if Node in Constructor:\r
- continue\r
- # remove edge e from the graph if Node has no constructor\r
- ConsumedByList[Item].remove(Node)\r
- EdgeRemoved = True\r
- if ConsumedByList[Item] == []:\r
- # insert Item into Q\r
- Q.insert(0, Item)\r
- break\r
- if Q != []:\r
- break\r
- # DAG is done if there's no more incoming edge for all nodes\r
- if Q == []:\r
- break\r
-\r
- # remove node from Q\r
- Node = Q.pop()\r
- # output Node\r
- SortedLibraryList.append(Node)\r
-\r
- # for each node Item with an edge e from Node to Item do\r
- for Item in LibraryList:\r
- if Node not in ConsumedByList[Item]:\r
- continue\r
- # remove edge e from the graph\r
- ConsumedByList[Item].remove(Node)\r
-\r
- if ConsumedByList[Item] != []:\r
- continue\r
- # insert Item into Q, if Item has no other incoming edges\r
- Q.insert(0, Item)\r
-\r
- #\r
- # if any remaining node Item in the graph has a constructor and an incoming edge, then the graph has a cycle\r
- #\r
- for Item in LibraryList:\r
- if ConsumedByList[Item] != [] and Item in Constructor and len(Constructor) > 1:\r
- ErrorMessage = "\tconsumed by " + "\n\tconsumed by ".join(str(L) for L in ConsumedByList[Item])\r
- EdkLogger.error("build", BUILD_ERROR, 'Library [%s] with constructors has a cycle' % str(Item),\r
- ExtraData=ErrorMessage, File=self.MetaFile)\r
- if Item not in SortedLibraryList:\r
- SortedLibraryList.append(Item)\r
-\r
- #\r
- # Build the list of constructor and destructir names\r
- # The DAG Topo sort produces the destructor order, so the list of constructors must generated in the reverse order\r
- #\r
- SortedLibraryList.reverse()\r
- return SortedLibraryList\r
-\r
+ return GetModuleLibInstances(Module,\r
+ self.Platform,\r
+ self.BuildDatabase,\r
+ self.Arch,\r
+ self.BuildTarget,\r
+ self.ToolChain,\r
+ self.MetaFile,\r
+ EdkLogger)\r
\r
## Override PCD setting (type, value, ...)\r
#\r
if FromPcd is not None:\r
if ToPcd.Pending and FromPcd.Type:\r
ToPcd.Type = FromPcd.Type\r
- elif (ToPcd.Type) and (FromPcd.Type)\\r
- and (ToPcd.Type != FromPcd.Type) and (ToPcd.Type in FromPcd.Type):\r
+ elif ToPcd.Type and FromPcd.Type\\r
+ and ToPcd.Type != FromPcd.Type and ToPcd.Type in FromPcd.Type:\r
if ToPcd.Type.strip() == TAB_PCDS_DYNAMIC_EX:\r
ToPcd.Type = FromPcd.Type\r
elif ToPcd.Type and FromPcd.Type \\r
if ToPcd.DefaultValue:\r
try:\r
ToPcd.DefaultValue = ValueExpressionEx(ToPcd.DefaultValue, ToPcd.DatumType, self._GuidDict)(True)\r
- except BadExpression, Value:\r
+ except BadExpression as Value:\r
EdkLogger.error('Parser', FORMAT_INVALID, 'PCD [%s.%s] Value "%s", %s' %(ToPcd.TokenSpaceGuidCName, ToPcd.TokenCName, ToPcd.DefaultValue, Value),\r
File=self.MetaFile)\r
\r
if (Key[0] == self.BuildRuleFamily and\r
(ModuleStyle is None or len(Key) < 3 or (len(Key) > 2 and Key[2] == ModuleStyle))):\r
Target, ToolChain, Arch, CommandType, Attr = Key[1].split('_')\r
- if Target == self.BuildTarget or Target == "*":\r
- if ToolChain == self.ToolChain or ToolChain == "*":\r
- if Arch == self.Arch or Arch == "*":\r
- if Options[Key].startswith("="):\r
- if OverrideList.get(Key[1]) is not None:\r
- OverrideList.pop(Key[1])\r
- OverrideList[Key[1]] = Options[Key]\r
+ if (Target == self.BuildTarget or Target == "*") and\\r
+ (ToolChain == self.ToolChain or ToolChain == "*") and\\r
+ (Arch == self.Arch or Arch == "*") and\\r
+ Options[Key].startswith("="):\r
+\r
+ if OverrideList.get(Key[1]) is not None:\r
+ OverrideList.pop(Key[1])\r
+ OverrideList[Key[1]] = Options[Key]\r
\r
#\r
# Use the highest priority value. \r
# Compare two Key, if one is included by another, choose the higher priority one\r
# \r
Target2, ToolChain2, Arch2, CommandType2, Attr2 = NextKey.split("_")\r
- if Target1 == Target2 or Target1 == "*" or Target2 == "*":\r
- if ToolChain1 == ToolChain2 or ToolChain1 == "*" or ToolChain2 == "*":\r
- if Arch1 == Arch2 or Arch1 == "*" or Arch2 == "*":\r
- if CommandType1 == CommandType2 or CommandType1 == "*" or CommandType2 == "*":\r
- if Attr1 == Attr2 or Attr1 == "*" or Attr2 == "*":\r
- if self.CalculatePriorityValue(NowKey) > self.CalculatePriorityValue(NextKey):\r
- if Options.get((self.BuildRuleFamily, NextKey)) is not None:\r
- Options.pop((self.BuildRuleFamily, NextKey))\r
- else:\r
- if Options.get((self.BuildRuleFamily, NowKey)) is not None:\r
- Options.pop((self.BuildRuleFamily, NowKey))\r
+ if (Target1 == Target2 or Target1 == "*" or Target2 == "*") and\\r
+ (ToolChain1 == ToolChain2 or ToolChain1 == "*" or ToolChain2 == "*") and\\r
+ (Arch1 == Arch2 or Arch1 == "*" or Arch2 == "*") and\\r
+ (CommandType1 == CommandType2 or CommandType1 == "*" or CommandType2 == "*") and\\r
+ (Attr1 == Attr2 or Attr1 == "*" or Attr2 == "*"):\r
+\r
+ if self.CalculatePriorityValue(NowKey) > self.CalculatePriorityValue(NextKey):\r
+ if Options.get((self.BuildRuleFamily, NextKey)) is not None:\r
+ Options.pop((self.BuildRuleFamily, NextKey))\r
+ else:\r
+ if Options.get((self.BuildRuleFamily, NowKey)) is not None:\r
+ Options.pop((self.BuildRuleFamily, NowKey))\r
\r
for Key in Options:\r
if ModuleStyle is not None and len (Key) > 2:\r
LibraryAutoGenList = property(_GetLibraryAutoGenList)\r
GenFdsCommand = property(_GenFdsCommand)\r
\r
+#\r
+# extend lists contained in a dictionary with lists stored in another dictionary\r
+# if CopyToDict is not derived from DefaultDict(list) then this may raise exception\r
+#\r
+def ExtendCopyDictionaryLists(CopyToDict, CopyFromDict):\r
+ for Key in CopyFromDict:\r
+ CopyToDict[Key].extend(CopyFromDict[Key])\r
+\r
+\r
## ModuleAutoGen class\r
#\r
# This class encapsules the AutoGen behaviors for the build tools. In addition to\r
self._MakeFileDir = None\r
\r
self._IncludePathList = None\r
- self._IncludePathLength = 0\r
self._AutoGenFileList = None\r
self._UnicodeFileList = None\r
self._VfrFileList = None\r
self._DerivedPackageList = None\r
self._ModulePcdList = None\r
self._LibraryPcdList = None\r
- self._PcdComments = OrderedDict()\r
+ self._PcdComments = OrderedListDict()\r
self._GuidList = None\r
self._GuidsUsedByPcd = None\r
- self._GuidComments = OrderedDict()\r
+ self._GuidComments = OrderedListDict()\r
self._ProtocolList = None\r
- self._ProtocolComments = OrderedDict()\r
+ self._ProtocolComments = OrderedListDict()\r
self._PpiList = None\r
- self._PpiComments = OrderedDict()\r
- self._DepexList = None\r
- self._DepexExpressionList = None\r
+ self._PpiComments = OrderedListDict()\r
+ self._DepexDict = None\r
+ self._DepexExpressionDict = None\r
self._BuildOption = None\r
self._BuildOptionIncPathList = None\r
self._BuildTargets = None\r
# \r
self._FixedAtBuildPcds = []\r
self.ConstPcd = {}\r
- return True\r
\r
def __repr__(self):\r
return "%s [%s]" % (self.MetaFile, self.Arch)\r
## Check if the module is library or not\r
def _IsLibrary(self):\r
if self._LibraryFlag is None:\r
- if self.Module.LibraryClass is not None and self.Module.LibraryClass != []:\r
- self._LibraryFlag = True\r
- else:\r
- self._LibraryFlag = False\r
+ self._LibraryFlag = True if self.Module.LibraryClass else False\r
return self._LibraryFlag\r
\r
## Check if the module is binary module or not\r
# @retval list The token list of the dependency expression after parsed\r
#\r
def _GetDepexTokenList(self):\r
- if self._DepexList is None:\r
- self._DepexList = {}\r
+ if self._DepexDict is None:\r
+ self._DepexDict = {}\r
if self.DxsFile or self.IsLibrary or TAB_DEPENDENCY_EXPRESSION_FILE in self.FileTypes:\r
- return self._DepexList\r
+ return self._DepexDict\r
\r
- self._DepexList[self.ModuleType] = []\r
+ self._DepexDict[self.ModuleType] = []\r
\r
- for ModuleType in self._DepexList:\r
- DepexList = self._DepexList[ModuleType]\r
+ for ModuleType in self._DepexDict:\r
+ DepexList = self._DepexDict[ModuleType]\r
#\r
# Append depex from dependent libraries, if not "BEFORE", "AFTER" expresion\r
#\r
break\r
if len(DepexList) > 0:\r
EdkLogger.verbose('')\r
- return self._DepexList\r
+ return self._DepexDict\r
\r
## Merge dependency expression\r
#\r
# @retval list The token list of the dependency expression after parsed\r
#\r
def _GetDepexExpressionTokenList(self):\r
- if self._DepexExpressionList is None:\r
- self._DepexExpressionList = {}\r
+ if self._DepexExpressionDict is None:\r
+ self._DepexExpressionDict = {}\r
if self.DxsFile or self.IsLibrary or TAB_DEPENDENCY_EXPRESSION_FILE in self.FileTypes:\r
- return self._DepexExpressionList\r
+ return self._DepexExpressionDict\r
\r
- self._DepexExpressionList[self.ModuleType] = ''\r
+ self._DepexExpressionDict[self.ModuleType] = ''\r
\r
- for ModuleType in self._DepexExpressionList:\r
- DepexExpressionList = self._DepexExpressionList[ModuleType]\r
+ for ModuleType in self._DepexExpressionDict:\r
+ DepexExpressionString = self._DepexExpressionDict[ModuleType]\r
#\r
# Append depex from dependent libraries, if not "BEFORE", "AFTER" expresion\r
#\r
for M in [self.Module] + self.DependentLibraryList:\r
Inherited = False\r
for D in M.DepexExpression[self.Arch, ModuleType]:\r
- if DepexExpressionList != '':\r
- DepexExpressionList += ' AND '\r
- DepexExpressionList += '('\r
- DepexExpressionList += D\r
- DepexExpressionList = DepexExpressionList.rstrip('END').strip()\r
- DepexExpressionList += ')'\r
+ if DepexExpressionString != '':\r
+ DepexExpressionString += ' AND '\r
+ DepexExpressionString += '('\r
+ DepexExpressionString += D\r
+ DepexExpressionString = DepexExpressionString.rstrip('END').strip()\r
+ DepexExpressionString += ')'\r
Inherited = True\r
if Inherited:\r
- EdkLogger.verbose("DEPEX[%s] (+%s) = %s" % (self.Name, M.BaseName, DepexExpressionList))\r
- if 'BEFORE' in DepexExpressionList or 'AFTER' in DepexExpressionList:\r
+ EdkLogger.verbose("DEPEX[%s] (+%s) = %s" % (self.Name, M.BaseName, DepexExpressionString))\r
+ if 'BEFORE' in DepexExpressionString or 'AFTER' in DepexExpressionString:\r
break\r
- if len(DepexExpressionList) > 0:\r
+ if len(DepexExpressionString) > 0:\r
EdkLogger.verbose('')\r
- self._DepexExpressionList[ModuleType] = DepexExpressionList\r
- return self._DepexExpressionList\r
+ self._DepexExpressionDict[ModuleType] = DepexExpressionString\r
+ return self._DepexExpressionDict\r
\r
# Get the tiano core user extension, it is contain dependent library.\r
# @retval: a list contain tiano core userextension.\r
\r
BuildOptionIncPathList = []\r
for Tool in ('CC', 'PP', 'VFRPP', 'ASLPP', 'ASLCC', 'APP', 'ASM'):\r
- Attr = 'FLAGS'\r
try:\r
- FlagOption = self.BuildOption[Tool][Attr]\r
+ FlagOption = self.BuildOption[Tool]['FLAGS']\r
except KeyError:\r
FlagOption = ''\r
\r
IncPathList = []\r
for Path in BuildOptIncludeRegEx.findall(FlagOption):\r
PathList = GetSplitList(Path, TAB_COMMA_SPLIT)\r
- IncPathList += [NormPath(PathEntry, self.Macros) for PathEntry in PathList]\r
+ IncPathList.extend(NormPath(PathEntry, self.Macros) for PathEntry in PathList)\r
\r
#\r
# EDK II modules must not reference header files outside of the packages they depend on or \r
# within the module's directory tree. Report error if violation.\r
#\r
- if self.AutoGenVersion >= 0x00010005 and len(IncPathList) > 0:\r
+ if self.AutoGenVersion >= 0x00010005:\r
for Path in IncPathList:\r
if (Path not in self.IncludePathList) and (CommonPath([Path, self.MetaFile.Dir]) != self.MetaFile.Dir):\r
ErrMsg = "The include directory for the EDK II module in this line is invalid %s specified in %s FLAGS '%s'" % (Path, Tool, FlagOption)\r
if not os.path.exists(SubDirectory):\r
CreateDirectory(SubDirectory)\r
LastTarget = None\r
- RuleChain = []\r
+ RuleChain = set()\r
SourceList = [File]\r
Index = 0\r
#\r
if FileType in RuleChain:\r
break\r
\r
- RuleChain.append(FileType)\r
+ RuleChain.add(FileType)\r
SourceList.extend(Target.Outputs)\r
LastTarget = Target\r
FileType = TAB_UNKNOWN_FILE\r
def _GetAutoGenFileList(self):\r
UniStringAutoGenC = True\r
IdfStringAutoGenC = True\r
- UniStringBinBuffer = StringIO()\r
- IdfGenBinBuffer = StringIO()\r
+ UniStringBinBuffer = BytesIO()\r
+ IdfGenBinBuffer = BytesIO()\r
if self.BuildType == 'UEFI_HII':\r
UniStringAutoGenC = False\r
IdfStringAutoGenC = False\r
self._DependentLibraryList = self.PlatformInfo.ApplyLibraryInstance(self.Module)\r
return self._DependentLibraryList\r
\r
- @staticmethod\r
- def UpdateComments(Recver, Src):\r
- for Key in Src:\r
- if Key not in Recver:\r
- Recver[Key] = []\r
- Recver[Key].extend(Src[Key])\r
## Get the list of PCDs from current module\r
#\r
# @retval list The list of PCD\r
if self._ModulePcdList is None:\r
# apply PCD settings from platform\r
self._ModulePcdList = self.PlatformInfo.ApplyPcdSetting(self.Module, self.Module.Pcds)\r
- self.UpdateComments(self._PcdComments, self.Module.PcdComments)\r
+ ExtendCopyDictionaryLists(self._PcdComments, self.Module.PcdComments)\r
return self._ModulePcdList\r
\r
## Get the list of PCDs from dependent libraries\r
self._LibraryPcdList = []\r
for Library in self.DependentLibraryList:\r
PcdsInLibrary = OrderedDict()\r
- self.UpdateComments(self._PcdComments, Library.PcdComments)\r
+ ExtendCopyDictionaryLists(self._PcdComments, Library.PcdComments)\r
for Key in Library.Pcds:\r
# skip duplicated PCDs\r
if Key in self.Module.Pcds or Key in Pcds:\r
self._GuidList.update(self.Module.Guids)\r
for Library in self.DependentLibraryList:\r
self._GuidList.update(Library.Guids)\r
- self.UpdateComments(self._GuidComments, Library.GuidComments)\r
- self.UpdateComments(self._GuidComments, self.Module.GuidComments)\r
+ ExtendCopyDictionaryLists(self._GuidComments, Library.GuidComments)\r
+ ExtendCopyDictionaryLists(self._GuidComments, self.Module.GuidComments)\r
return self._GuidList\r
\r
def GetGuidsUsedByPcd(self):\r
self._ProtocolList.update(self.Module.Protocols)\r
for Library in self.DependentLibraryList:\r
self._ProtocolList.update(Library.Protocols)\r
- self.UpdateComments(self._ProtocolComments, Library.ProtocolComments)\r
- self.UpdateComments(self._ProtocolComments, self.Module.ProtocolComments)\r
+ ExtendCopyDictionaryLists(self._ProtocolComments, Library.ProtocolComments)\r
+ ExtendCopyDictionaryLists(self._ProtocolComments, self.Module.ProtocolComments)\r
return self._ProtocolList\r
\r
## Get the PPI value mapping\r
self._PpiList.update(self.Module.Ppis)\r
for Library in self.DependentLibraryList:\r
self._PpiList.update(Library.Ppis)\r
- self.UpdateComments(self._PpiComments, Library.PpiComments)\r
- self.UpdateComments(self._PpiComments, self.Module.PpiComments)\r
+ ExtendCopyDictionaryLists(self._PpiComments, Library.PpiComments)\r
+ ExtendCopyDictionaryLists(self._PpiComments, self.Module.PpiComments)\r
return self._PpiList\r
\r
## Get the list of include search path\r
return self._IncludePathList\r
\r
def _GetIncludePathLength(self):\r
- self._IncludePathLength = 0\r
- if self._IncludePathList:\r
- for inc in self._IncludePathList:\r
- self._IncludePathLength += len(' ' + inc)\r
- return self._IncludePathLength\r
+ return sum(len(inc)+1 for inc in self._IncludePathList)\r
\r
## Get HII EX PCDs which maybe used by VFR\r
#\r
for Pcd in self.PlatformInfo.Platform.Pcds.values():\r
if Pcd.Type != TAB_PCDS_DYNAMIC_EX_HII:\r
continue\r
- for SkuName in Pcd.SkuInfoList:\r
- SkuInfo = Pcd.SkuInfoList[SkuName]\r
- Name = ConvertStringToByteArray(SkuInfo.VariableName)\r
+ for SkuInfo in Pcd.SkuInfoList.values():\r
Value = GuidValue(SkuInfo.VariableGuid, self.PlatformInfo.PackageList, self.MetaFile.Path)\r
if not Value:\r
continue\r
+ Name = ConvertStringToByteArray(SkuInfo.VariableName)\r
Guid = GuidStructureStringToGuidString(Value)\r
if (Name, Guid) in NameGuids and Pcd not in HiiExPcds:\r
HiiExPcds.append(Pcd)\r
# search the .map file to find the offset of vfr binary in the PE32+/TE file. \r
#\r
VfrUniBaseName[SourceFile.BaseName] = (SourceFile.BaseName + "Bin")\r
- if SourceFile.Type.upper() == ".UNI" :\r
+ elif SourceFile.Type.upper() == ".UNI" :\r
#\r
# search the .map file to find the offset of Uni strings binary in the PE32+/TE file. \r
#\r
VfrUniBaseName["UniOffsetName"] = (self.Name + "Strings")\r
\r
- if len(VfrUniBaseName) == 0:\r
+ if not VfrUniBaseName:\r
return None\r
MapFileName = os.path.join(self.OutputDir, self.Name + ".map")\r
EfiFileName = os.path.join(self.OutputDir, self.Name + ".efi")\r
try:\r
fInputfile = open(UniVfrOffsetFileName, "wb+", 0)\r
except:\r
- EdkLogger.error("build", FILE_OPEN_FAILURE, "File open failed for %s" % UniVfrOffsetFileName,None)\r
+ EdkLogger.error("build", FILE_OPEN_FAILURE, "File open failed for %s" % UniVfrOffsetFileName, None)\r
\r
- # Use a instance of StringIO to cache data\r
- fStringIO = StringIO('') \r
+ # Use a instance of BytesIO to cache data\r
+ fStringIO = BytesIO('')\r
\r
for Item in VfrUniOffsetList:\r
if (Item[0].find("Strings") != -1):\r
fInputfile.write (fStringIO.getvalue())\r
except:\r
EdkLogger.error("build", FILE_WRITE_FAILURE, "Write data to file %s failed, please check whether the "\r
- "file been locked or using by other applications." %UniVfrOffsetFileName,None)\r
+ "file been locked or using by other applications." %UniVfrOffsetFileName, None)\r
\r
fStringIO.close ()\r
fInputfile.close ()\r
#\r
def CreateAsBuiltInf(self, IsOnlyCopy = False):\r
self.OutputFile = set()\r
- if IsOnlyCopy:\r
- if GlobalData.gBinCacheDest:\r
- self.CopyModuleToCache()\r
- return\r
+ if IsOnlyCopy and GlobalData.gBinCacheDest:\r
+ self.CopyModuleToCache()\r
+ return\r
\r
if self.IsAsBuiltInfCreated:\r
return\r
PcdTokenSpaceList = []\r
for Pcd in self.ModulePcdList + self.LibraryPcdList:\r
if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:\r
- PatchablePcds += [Pcd]\r
+ PatchablePcds.append(Pcd)\r
PcdCheckList.append((Pcd.TokenCName, Pcd.TokenSpaceGuidCName, TAB_PCDS_PATCHABLE_IN_MODULE))\r
elif Pcd.Type in PCD_DYNAMIC_EX_TYPE_SET:\r
if Pcd not in Pcds:\r
- Pcds += [Pcd]\r
+ Pcds.append(Pcd)\r
PcdCheckList.append((Pcd.TokenCName, Pcd.TokenSpaceGuidCName, TAB_PCDS_DYNAMIC_EX))\r
PcdCheckList.append((Pcd.TokenCName, Pcd.TokenSpaceGuidCName, TAB_PCDS_DYNAMIC))\r
PcdTokenSpaceList.append(Pcd.TokenSpaceGuidCName)\r
for Index in range(len(BeChecked)):\r
for Item in CheckList[Index]:\r
if Item in BeChecked[Index]:\r
- Packages += [Package]\r
+ Packages.append(Package)\r
Found = True\r
break\r
- if Found: break\r
+ if Found:\r
+ break\r
\r
VfrPcds = self._GetPcdsMaybeUsedByVfr()\r
for Pkg in self.PlatformInfo.PackageList:\r
for VfrPcd in VfrPcds:\r
if ((VfrPcd.TokenCName, VfrPcd.TokenSpaceGuidCName, TAB_PCDS_DYNAMIC_EX) in Pkg.Pcds or\r
(VfrPcd.TokenCName, VfrPcd.TokenSpaceGuidCName, TAB_PCDS_DYNAMIC) in Pkg.Pcds):\r
- Packages += [Pkg]\r
+ Packages.append(Pkg)\r
break\r
\r
- ModuleType = self.ModuleType\r
- if ModuleType == SUP_MODULE_UEFI_DRIVER and self.DepexGenerated:\r
- ModuleType = SUP_MODULE_DXE_DRIVER\r
-\r
- DriverType = ''\r
- if self.PcdIsDriver != '':\r
- DriverType = self.PcdIsDriver\r
-\r
+ ModuleType = SUP_MODULE_DXE_DRIVER if self.ModuleType == SUP_MODULE_UEFI_DRIVER and self.DepexGenerated else self.ModuleType\r
+ DriverType = self.PcdIsDriver if self.PcdIsDriver else ''\r
Guid = self.Guid\r
MDefs = self.Module.Defines\r
\r
'module_uefi_hii_resource_section' : [MDefs['UEFI_HII_RESOURCE_SECTION']] if 'UEFI_HII_RESOURCE_SECTION' in MDefs else [],\r
'module_uni_file' : [MDefs['MODULE_UNI_FILE']] if 'MODULE_UNI_FILE' in MDefs else [],\r
'module_arch' : self.Arch,\r
- 'package_item' : ['%s' % (Package.MetaFile.File.replace('\\', '/')) for Package in Packages],\r
+ 'package_item' : [Package.MetaFile.File.replace('\\', '/') for Package in Packages],\r
'binary_item' : [],\r
'patchablepcd_item' : [],\r
'pcd_item' : [],\r
AsBuiltInfDict['module_inf_version'] = gInfSpecVersion\r
\r
if DriverType:\r
- AsBuiltInfDict['pcd_is_driver_string'] += [DriverType]\r
+ AsBuiltInfDict['pcd_is_driver_string'].append(DriverType)\r
\r
if 'UEFI_SPECIFICATION_VERSION' in self.Specification:\r
- AsBuiltInfDict['module_uefi_specification_version'] += [self.Specification['UEFI_SPECIFICATION_VERSION']]\r
+ AsBuiltInfDict['module_uefi_specification_version'].append(self.Specification['UEFI_SPECIFICATION_VERSION'])\r
if 'PI_SPECIFICATION_VERSION' in self.Specification:\r
- AsBuiltInfDict['module_pi_specification_version'] += [self.Specification['PI_SPECIFICATION_VERSION']]\r
+ AsBuiltInfDict['module_pi_specification_version'].append(self.Specification['PI_SPECIFICATION_VERSION'])\r
\r
OutputDir = self.OutputDir.replace('\\', '/').strip('/')\r
DebugDir = self.DebugDir.replace('\\', '/').strip('/')\r
if os.path.isabs(File):\r
File = File.replace('\\', '/').strip('/').replace(OutputDir, '').strip('/')\r
if Item.Target.Ext.lower() == '.aml':\r
- AsBuiltInfDict['binary_item'] += ['ASL|' + File]\r
+ AsBuiltInfDict['binary_item'].append('ASL|' + File)\r
elif Item.Target.Ext.lower() == '.acpi':\r
- AsBuiltInfDict['binary_item'] += ['ACPI|' + File]\r
+ AsBuiltInfDict['binary_item'].append('ACPI|' + File)\r
elif Item.Target.Ext.lower() == '.efi':\r
- AsBuiltInfDict['binary_item'] += ['PE32|' + self.Name + '.efi']\r
+ AsBuiltInfDict['binary_item'].append('PE32|' + self.Name + '.efi')\r
else:\r
- AsBuiltInfDict['binary_item'] += ['BIN|' + File]\r
+ AsBuiltInfDict['binary_item'].append('BIN|' + File)\r
if self.DepexGenerated:\r
self.OutputFile.add(self.Name + '.depex')\r
if self.ModuleType in [SUP_MODULE_PEIM]:\r
- AsBuiltInfDict['binary_item'] += ['PEI_DEPEX|' + self.Name + '.depex']\r
- if self.ModuleType in [SUP_MODULE_DXE_DRIVER, SUP_MODULE_DXE_RUNTIME_DRIVER, SUP_MODULE_DXE_SAL_DRIVER, SUP_MODULE_UEFI_DRIVER]:\r
- AsBuiltInfDict['binary_item'] += ['DXE_DEPEX|' + self.Name + '.depex']\r
- if self.ModuleType in [SUP_MODULE_DXE_SMM_DRIVER]:\r
- AsBuiltInfDict['binary_item'] += ['SMM_DEPEX|' + self.Name + '.depex']\r
+ AsBuiltInfDict['binary_item'].append('PEI_DEPEX|' + self.Name + '.depex')\r
+ elif self.ModuleType in [SUP_MODULE_DXE_DRIVER, SUP_MODULE_DXE_RUNTIME_DRIVER, SUP_MODULE_DXE_SAL_DRIVER, SUP_MODULE_UEFI_DRIVER]:\r
+ AsBuiltInfDict['binary_item'].append('DXE_DEPEX|' + self.Name + '.depex')\r
+ elif self.ModuleType in [SUP_MODULE_DXE_SMM_DRIVER]:\r
+ AsBuiltInfDict['binary_item'].append('SMM_DEPEX|' + self.Name + '.depex')\r
\r
Bin = self._GenOffsetBin()\r
if Bin:\r
- AsBuiltInfDict['binary_item'] += ['BIN|%s' % Bin]\r
+ AsBuiltInfDict['binary_item'].append('BIN|%s' % Bin)\r
self.OutputFile.add(Bin)\r
\r
for Root, Dirs, Files in os.walk(OutputDir):\r
for File in Files:\r
if File.lower().endswith('.pdb'):\r
- AsBuiltInfDict['binary_item'] += ['DISPOSABLE|' + File]\r
+ AsBuiltInfDict['binary_item'].append('DISPOSABLE|' + File)\r
self.OutputFile.add(File)\r
HeaderComments = self.Module.HeaderComments\r
StartPos = 0\r
]\r
for Item in GenList:\r
for CName in Item[0]:\r
- Comments = ''\r
- if CName in Item[1]:\r
- Comments = '\n '.join(Item[1][CName])\r
- Entry = CName\r
- if Comments:\r
- Entry = Comments + '\n ' + CName\r
+ Comments = '\n '.join(Item[1][CName]) if CName in Item[1] else ''\r
+ Entry = Comments + '\n ' + CName if Comments else CName\r
AsBuiltInfDict[Item[2]].append(Entry)\r
PatchList = parsePcdInfoFromMapFile(\r
os.path.join(self.OutputDir, self.Name + '.map'),\r
PcdItem = PcdComments + '\n ' + PcdItem\r
AsBuiltInfDict['patchablepcd_item'].append(PcdItem)\r
\r
- HiiPcds = set()\r
for Pcd in Pcds + VfrPcds:\r
- PcdComments = ''\r
PcdCommentList = []\r
HiiInfo = ''\r
- SkuId = ''\r
TokenCName = Pcd.TokenCName\r
for PcdItem in GlobalData.MixedPcd:\r
if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) in GlobalData.MixedPcd[PcdItem]:\r
if Pcd.Type == TAB_PCDS_DYNAMIC_EX_HII:\r
for SkuName in Pcd.SkuInfoList:\r
SkuInfo = Pcd.SkuInfoList[SkuName]\r
- SkuId = SkuInfo.SkuId\r
HiiInfo = '## %s|%s|%s' % (SkuInfo.VariableName, SkuInfo.VariableGuid, SkuInfo.VariableOffset)\r
break\r
- if SkuId:\r
- #\r
- # Don't generate duplicated HII PCD\r
- #\r
- if (SkuId, Pcd.TokenSpaceGuidCName, Pcd.TokenCName) in HiiPcds:\r
- continue\r
- HiiPcds.add((SkuId, Pcd.TokenSpaceGuidCName, Pcd.TokenCName))\r
if (Pcd.TokenSpaceGuidCName, Pcd.TokenCName) in self._PcdComments:\r
PcdCommentList = self._PcdComments[Pcd.TokenSpaceGuidCName, Pcd.TokenCName][:]\r
if HiiInfo:\r
PcdEntry = Pcd.TokenSpaceGuidCName + '.' + TokenCName\r
if PcdComments:\r
PcdEntry = PcdComments + '\n ' + PcdEntry\r
- AsBuiltInfDict['pcd_item'] += [PcdEntry]\r
+ AsBuiltInfDict['pcd_item'].append(PcdEntry)\r
for Item in self.BuildOption:\r
if 'FLAGS' in self.BuildOption[Item]:\r
- AsBuiltInfDict['flags_item'] += ['%s:%s_%s_%s_%s_FLAGS = %s' % (self.ToolChainFamily, self.BuildTarget, self.ToolChain, self.Arch, Item, self.BuildOption[Item]['FLAGS'].strip())]\r
+ AsBuiltInfDict['flags_item'].append('%s:%s_%s_%s_%s_FLAGS = %s' % (self.ToolChainFamily, self.BuildTarget, self.ToolChain, self.Arch, Item, self.BuildOption[Item]['FLAGS'].strip()))\r
\r
# Generated LibraryClasses section in comments.\r
for Library in self.LibraryAutoGenList:\r
- AsBuiltInfDict['libraryclasses_item'] += [Library.MetaFile.File.replace('\\', '/')]\r
+ AsBuiltInfDict['libraryclasses_item'].append(Library.MetaFile.File.replace('\\', '/'))\r
\r
# Generated UserExtensions TianoCore section.\r
# All tianocore user extensions are copied.\r
AsBuiltInfDict['userextension_tianocore_item'] = UserExtStr\r
\r
# Generated depex expression section in comments.\r
- AsBuiltInfDict['depexsection_item'] = ''\r
DepexExpresion = self._GetDepexExpresionString()\r
- if DepexExpresion:\r
- AsBuiltInfDict['depexsection_item'] = DepexExpresion\r
+ AsBuiltInfDict['depexsection_item'] = DepexExpresion if DepexExpresion else ''\r
\r
AsBuiltInf = TemplateString()\r
AsBuiltInf.Append(gAsBuiltInfHeaderString.Replace(AsBuiltInfDict))\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
+ 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
Dpx = GenDepex.DependencyExpression(self.DepexList[ModuleType], ModuleType, True)\r
DpxFile = gAutoGenDepexFileName % {"module_name" : self.Name}\r
\r
- if len(Dpx.PostfixNotation) <> 0:\r
+ if len(Dpx.PostfixNotation) != 0:\r
self.DepexGenerated = True\r
\r
if Dpx.Generate(path.join(self.OutputDir, DpxFile)):\r
if self.Name not in GlobalData.gModuleHash[self.Arch]:\r
GlobalData.gModuleHash[self.Arch][self.Name] = m.hexdigest()\r
if GlobalData.gBinCacheSource:\r
- CacheValid = self.AttemptModuleCacheCopy()\r
- if CacheValid:\r
+ if self.AttemptModuleCacheCopy():\r
return False\r
return SaveFileOnChange(ModuleHashFile, m.hexdigest(), True)\r
\r
if SrcTimeStamp > DstTimeStamp:\r
return False\r
\r
- with open(self.GetTimeStampPath(),'r') as f:\r
+ with open(self.GetTimeStampPath(), 'r') as f:\r
for source in f:\r
source = source.rstrip('\n')\r
if not os.path.exists(source):\r
return self._TimeStampPath\r
def CreateTimeStamp(self, Makefile):\r
\r
- FileSet = set()\r
-\r
- FileSet.add (self.MetaFile.Path)\r
+ FileSet = {self.MetaFile.Path}\r
\r
for SourceFile in self.Module.Sources:\r
FileSet.add (SourceFile.Path)\r
os.remove (self.GetTimeStampPath())\r
with open(self.GetTimeStampPath(), 'w+') as file:\r
for f in FileSet:\r
- print >> file, f\r
+ print(f, file=file)\r
\r
Module = property(_GetModule)\r
Name = property(_GetBaseName)\r
PpiList = property(_GetPpiList)\r
DepexList = property(_GetDepexTokenList)\r
DxsFile = property(_GetDxsFile)\r
- DepexExpressionList = property(_GetDepexExpressionTokenList)\r
+ DepexExpressionDict = property(_GetDepexExpressionTokenList)\r
BuildOption = property(_GetModuleBuildOption)\r
BuildOptionIncPathList = property(_GetBuildOptionIncPathList)\r
BuildCommand = property(_GetBuildCommand)\r
projects / mirror_edk2.git / blobdiff