# Generate AutoGen.h, AutoGen.c and *.depex files\r
#\r
# Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2018, Hewlett Packard Enterprise Development, L.P.<BR>\r
+#\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
from Common.BuildToolError import *\r
from Common.DataType import *\r
from Common.Misc import *\r
-from Common.String import *\r
+from Common.StringUtils import *\r
import Common.GlobalData as GlobalData\r
from GenFds.FdfParser import *\r
from CommonDataClass.CommonClass import SkuInfoClass\r
def _InitWorker(self, WorkspaceDir, ActivePlatform, Target, Toolchain, ArchList, MetaFileDb,\r
BuildConfig, ToolDefinition, FlashDefinitionFile='', Fds=None, Fvs=None, Caps=None, SkuId='', UniFlag=None,\r
Progress=None, BuildModule=None):\r
- if Fds is None:\r
- Fds = []\r
- if Fvs is None:\r
- Fvs = []\r
- if Caps is None:\r
- Caps = []\r
self.BuildDatabase = MetaFileDb\r
self.MetaFile = ActivePlatform\r
self.WorkspaceDir = WorkspaceDir\r
- self.Platform = self.BuildDatabase[self.MetaFile, 'COMMON', Target, Toolchain]\r
+ self.Platform = self.BuildDatabase[self.MetaFile, TAB_ARCH_COMMON, Target, Toolchain]\r
GlobalData.gActivePlatform = self.Platform\r
self.BuildTarget = Target\r
self.ToolChain = Toolchain\r
self.TargetTxt = BuildConfig\r
self.ToolDef = ToolDefinition\r
self.FdfFile = FlashDefinitionFile\r
- self.FdTargetList = Fds\r
- self.FvTargetList = Fvs\r
- self.CapTargetList = Caps\r
+ self.FdTargetList = Fds if Fds else []\r
+ self.FvTargetList = Fvs if Fvs else []\r
+ self.CapTargetList = Caps if Caps else []\r
self.AutoGenObjectList = []\r
self._BuildDir = None\r
self._FvDir = None\r
# but the path (self.MetaFile.Path) is the real path\r
for key in self.FdfProfile.InfDict:\r
if key == 'ArchTBD':\r
- MetaFile_cache = {}\r
+ MetaFile_cache = defaultdict(set)\r
for Arch in self.ArchList:\r
Current_Platform_cache = self.BuildDatabase[self.MetaFile, Arch, Target, Toolchain]\r
- MetaFile_cache[Arch] = set()\r
for Pkey in Current_Platform_cache.Modules:\r
MetaFile_cache[Arch].add(Current_Platform_cache.Modules[Pkey].MetaFile)\r
for Inf in self.FdfProfile.InfDict[key]:\r
Platform = self.BuildDatabase[self.MetaFile, Arch, Target, Toolchain]\r
PlatformPcds = Platform.Pcds\r
self._GuidDict = Platform._GuidDict\r
- SourcePcdDict = {'DynamicEx':set(), 'PatchableInModule':set(),'Dynamic':set(),'FixedAtBuild':set()}\r
- BinaryPcdDict = {'DynamicEx':set(), 'PatchableInModule':set()}\r
+ SourcePcdDict = {TAB_PCDS_DYNAMIC_EX:set(), TAB_PCDS_PATCHABLE_IN_MODULE:set(),TAB_PCDS_DYNAMIC:set(),TAB_PCDS_FIXED_AT_BUILD:set()}\r
+ BinaryPcdDict = {TAB_PCDS_DYNAMIC_EX:set(), TAB_PCDS_PATCHABLE_IN_MODULE:set()}\r
SourcePcdDict_Keys = SourcePcdDict.keys()\r
BinaryPcdDict_Keys = BinaryPcdDict.keys()\r
\r
if BuildData.Pcds[key].Pending:\r
if key in Platform.Pcds:\r
PcdInPlatform = Platform.Pcds[key]\r
- if PcdInPlatform.Type not in [None, '']:\r
+ if PcdInPlatform.Type:\r
BuildData.Pcds[key].Type = PcdInPlatform.Type\r
+ BuildData.Pcds[key].Pending = False\r
\r
if BuildData.MetaFile in Platform.Modules:\r
PlatformModule = Platform.Modules[str(BuildData.MetaFile)]\r
if key in PlatformModule.Pcds:\r
PcdInPlatform = PlatformModule.Pcds[key]\r
- if PcdInPlatform.Type not in [None, '']:\r
+ if PcdInPlatform.Type:\r
BuildData.Pcds[key].Type = PcdInPlatform.Type\r
-\r
- if 'DynamicEx' in BuildData.Pcds[key].Type:\r
+ BuildData.Pcds[key].Pending = False\r
+ else:\r
+ #Pcd used in Library, Pcd Type from reference module if Pcd Type is Pending\r
+ if BuildData.Pcds[key].Pending:\r
+ MGen = ModuleAutoGen(self, BuildData.MetaFile, Target, Toolchain, Arch, self.MetaFile)\r
+ if MGen and MGen.IsLibrary:\r
+ if MGen in PGen.LibraryAutoGenList:\r
+ ReferenceModules = MGen._ReferenceModules\r
+ for ReferenceModule in ReferenceModules:\r
+ if ReferenceModule.MetaFile in Platform.Modules:\r
+ RefPlatformModule = Platform.Modules[str(ReferenceModule.MetaFile)]\r
+ if key in RefPlatformModule.Pcds:\r
+ PcdInReferenceModule = RefPlatformModule.Pcds[key]\r
+ if PcdInReferenceModule.Type:\r
+ BuildData.Pcds[key].Type = PcdInReferenceModule.Type\r
+ BuildData.Pcds[key].Pending = False\r
+ break\r
+\r
+ if TAB_PCDS_DYNAMIC_EX in BuildData.Pcds[key].Type:\r
if BuildData.IsBinaryModule:\r
- BinaryPcdDict['DynamicEx'].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
+ BinaryPcdDict[TAB_PCDS_DYNAMIC_EX].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
else:\r
- SourcePcdDict['DynamicEx'].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
+ SourcePcdDict[TAB_PCDS_DYNAMIC_EX].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
\r
- elif 'PatchableInModule' in BuildData.Pcds[key].Type:\r
+ elif TAB_PCDS_PATCHABLE_IN_MODULE in BuildData.Pcds[key].Type:\r
if BuildData.MetaFile.Ext == '.inf':\r
if BuildData.IsBinaryModule:\r
- BinaryPcdDict['PatchableInModule'].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
+ BinaryPcdDict[TAB_PCDS_PATCHABLE_IN_MODULE].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
else:\r
- SourcePcdDict['PatchableInModule'].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
+ SourcePcdDict[TAB_PCDS_PATCHABLE_IN_MODULE].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
\r
- elif 'Dynamic' in BuildData.Pcds[key].Type:\r
- SourcePcdDict['Dynamic'].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
- elif 'FixedAtBuild' in BuildData.Pcds[key].Type:\r
- SourcePcdDict['FixedAtBuild'].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
+ elif TAB_PCDS_DYNAMIC in BuildData.Pcds[key].Type:\r
+ SourcePcdDict[TAB_PCDS_DYNAMIC].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
+ elif TAB_PCDS_FIXED_AT_BUILD in BuildData.Pcds[key].Type:\r
+ SourcePcdDict[TAB_PCDS_FIXED_AT_BUILD].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
else:\r
pass\r
#\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="%s" % '\n\t'.join(str(P[1]+'.'+P[0]) for P in Intersections)\r
)\r
\r
#\r
if (BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName) == SinglePcd:\r
for item in GlobalData.MixedPcd[SinglePcd]:\r
Pcd_Type = item[0].split('_')[-1]\r
- if (Pcd_Type == BuildData.Pcds[key].Type) or (Pcd_Type == TAB_PCDS_DYNAMIC_EX and BuildData.Pcds[key].Type in GenC.gDynamicExPcd) or \\r
- (Pcd_Type == TAB_PCDS_DYNAMIC and BuildData.Pcds[key].Type in GenC.gDynamicPcd):\r
+ if (Pcd_Type == BuildData.Pcds[key].Type) or (Pcd_Type == TAB_PCDS_DYNAMIC_EX and BuildData.Pcds[key].Type in PCD_DYNAMIC_EX_TYPE_SET) or \\r
+ (Pcd_Type == TAB_PCDS_DYNAMIC and BuildData.Pcds[key].Type in PCD_DYNAMIC_TYPE_SET):\r
Value = BuildData.Pcds[key]\r
Value.TokenCName = BuildData.Pcds[key].TokenCName + '_' + Pcd_Type\r
if len(key) == 2:\r
return True\r
\r
def _GenPkgLevelHash(self, Pkg):\r
+ if Pkg.PackageName in GlobalData.gPackageHash[Pkg.Arch]:\r
+ return\r
+\r
PkgDir = os.path.join(self.BuildDir, Pkg.Arch, Pkg.PackageName)\r
CreateDirectory(PkgDir)\r
HashFile = os.path.join(PkgDir, Pkg.PackageName + '.hash')\r
m.update(Content)\r
# Get include files hash value\r
if Pkg.Includes:\r
- for inc in Pkg.Includes:\r
+ for inc in sorted(Pkg.Includes, key=lambda x: str(x)):\r
for Root, Dirs, Files in os.walk(str(inc)):\r
- for File in Files:\r
+ for File in sorted(Files):\r
File_Path = os.path.join(Root, File)\r
f = open(File_Path, 'r')\r
Content = f.read()\r
f.close()\r
m.update(Content)\r
SaveFileOnChange(HashFile, m.hexdigest(), True)\r
- if Pkg.PackageName not in GlobalData.gPackageHash[Pkg.Arch]:\r
- GlobalData.gPackageHash[Pkg.Arch][Pkg.PackageName] = m.hexdigest()\r
+ GlobalData.gPackageHash[Pkg.Arch][Pkg.PackageName] = m.hexdigest()\r
\r
def _GetMetaFiles(self, Target, Toolchain, Arch):\r
AllWorkSpaceMetaFiles = set()\r
for Module in Pa.ModuleAutoGenList:\r
if path.normpath(Module.MetaFile.File) == path.normpath(FfsFile.InfFileName):\r
InfFoundFlag = True\r
- if not Module.Guid.upper() in _GuidDict.keys():\r
+ if Module.Guid.upper() not in _GuidDict:\r
_GuidDict[Module.Guid.upper()] = FfsFile\r
break\r
else:\r
# Here we just need to get FILE_GUID from INF file, use 'COMMON' as ARCH attribute. and use \r
# BuildObject from one of AutoGenObjectList is enough.\r
#\r
- InfObj = self.AutoGenObjectList[0].BuildDatabase.WorkspaceDb.BuildObject[PathClassObj, 'COMMON', self.BuildTarget, self.ToolChain]\r
- if not InfObj.Guid.upper() in _GuidDict.keys():\r
+ InfObj = self.AutoGenObjectList[0].BuildDatabase.WorkspaceDb.BuildObject[PathClassObj, TAB_ARCH_COMMON, self.BuildTarget, self.ToolChain]\r
+ if InfObj.Guid.upper() not in _GuidDict:\r
_GuidDict[InfObj.Guid.upper()] = FfsFile\r
else:\r
EdkLogger.error("build",\r
"The format of PCD value is incorrect. PCD: %s , Value: %s\n" % (_PcdName, PcdItem.DefaultValue),\r
ExtraData=self.FdfFile)\r
\r
- if not _PcdGuidString.upper() in _GuidDict.keys():\r
+ if _PcdGuidString.upper() not in _GuidDict:\r
_GuidDict[_PcdGuidString.upper()] = FfsFile\r
PcdFoundFlag = True\r
break\r
FfsFile.NameGuid.upper()),\r
ExtraData=self.FdfFile)\r
\r
- if not FfsFile.NameGuid.upper() in _GuidDict.keys():\r
+ if FfsFile.NameGuid.upper() not in _GuidDict:\r
_GuidDict[FfsFile.NameGuid.upper()] = FfsFile\r
else:\r
#\r
\r
def _CheckPcdDefineAndType(self):\r
PcdTypeList = [\r
- "FixedAtBuild", "PatchableInModule", "FeatureFlag",\r
- "Dynamic", #"DynamicHii", "DynamicVpd",\r
- "DynamicEx", # "DynamicExHii", "DynamicExVpd"\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
\r
# This dict store PCDs which are not used by any modules with specified arches\r
continue\r
\r
# Try to remove Hii and Vpd suffix\r
- if PcdType.startswith("DynamicEx"):\r
- PcdType = "DynamicEx"\r
- elif PcdType.startswith("Dynamic"):\r
- PcdType = "Dynamic"\r
+ if PcdType.startswith(TAB_PCDS_DYNAMIC_EX):\r
+ PcdType = TAB_PCDS_DYNAMIC_EX\r
+ elif PcdType.startswith(TAB_PCDS_DYNAMIC):\r
+ PcdType = TAB_PCDS_DYNAMIC\r
\r
for Package in Pa.PackageList:\r
# Key of DEC's Pcds dictionary is PcdCName, TokenSpaceGuid, PcdType\r
## Return the directory to store FV files\r
def _GetFvDir(self):\r
if self._FvDir is None:\r
- self._FvDir = path.join(self.BuildDir, 'FV')\r
+ self._FvDir = path.join(self.BuildDir, TAB_FV_DIRECTORY)\r
return self._FvDir\r
\r
## Return the directory to store all intermediate and final files built\r
continue\r
else:\r
DscPcd = self.NonDynamicPcdDict[(Pcd.TokenCName,Pcd.TokenSpaceGuidCName)]\r
- if DscPcd.Type != "FixedAtBuild":\r
+ if DscPcd.Type != TAB_PCDS_FIXED_AT_BUILD:\r
continue\r
if key in ShareFixedAtBuildPcdsSameValue and ShareFixedAtBuildPcdsSameValue[key]: \r
LibAuto.ConstPcd[key] = FixedAtBuildPcds[key]\r
\r
def UpdateNVStoreMaxSize(self,OrgVpdFile):\r
if self.VariableInfo:\r
- VpdMapFilePath = os.path.join(self.BuildDir, "FV", "%s.map" % self.Platform.VpdToolGuid)\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
\r
if PcdNvStoreDfBuffer:\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
- default_skuobj = PcdNvStoreDfBuffer[0].SkuInfoList.get("DEFAULT")\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
\r
default_skuobj.DefaultValue = var_data\r
PcdNvStoreDfBuffer[0].DefaultValue = var_data\r
PcdNvStoreDfBuffer[0].SkuInfoList.clear()\r
- PcdNvStoreDfBuffer[0].SkuInfoList['DEFAULT'] = default_skuobj\r
+ PcdNvStoreDfBuffer[0].SkuInfoList[TAB_DEFAULT] = default_skuobj\r
PcdNvStoreDfBuffer[0].MaxDatumSize = str(len(default_skuobj.DefaultValue.split(",")))\r
\r
return OrgVpdFile\r
if (self.Platform.Pcds[key].TokenCName, self.Platform.Pcds[key].TokenSpaceGuidCName) == SinglePcd:\r
for item in GlobalData.MixedPcd[SinglePcd]:\r
Pcd_Type = item[0].split('_')[-1]\r
- if (Pcd_Type == self.Platform.Pcds[key].Type) or (Pcd_Type == TAB_PCDS_DYNAMIC_EX and self.Platform.Pcds[key].Type in GenC.gDynamicExPcd) or \\r
- (Pcd_Type == TAB_PCDS_DYNAMIC and self.Platform.Pcds[key].Type in GenC.gDynamicPcd):\r
+ if (Pcd_Type == self.Platform.Pcds[key].Type) or (Pcd_Type == TAB_PCDS_DYNAMIC_EX and self.Platform.Pcds[key].Type in PCD_DYNAMIC_EX_TYPE_SET) or \\r
+ (Pcd_Type == TAB_PCDS_DYNAMIC and self.Platform.Pcds[key].Type in PCD_DYNAMIC_TYPE_SET):\r
Value = self.Platform.Pcds[key]\r
Value.TokenCName = self.Platform.Pcds[key].TokenCName + '_' + Pcd_Type\r
if len(key) == 2:\r
\r
for PcdFromModule in M.ModulePcdList + M.LibraryPcdList:\r
# make sure that the "VOID*" kind of datum has MaxDatumSize set\r
- if PcdFromModule.DatumType == "VOID*" and PcdFromModule.MaxDatumSize in [None, '']:\r
+ if PcdFromModule.DatumType == TAB_VOID and not PcdFromModule.MaxDatumSize:\r
NoDatumTypePcdList.add("%s.%s [%s]" % (PcdFromModule.TokenSpaceGuidCName, PcdFromModule.TokenCName, F))\r
\r
# Check the PCD from Binary INF or Source INF\r
PcdFromModule.IsFromBinaryInf = True\r
\r
# Check the PCD from DSC or not \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
+ PcdFromModule.IsFromDsc = (PcdFromModule.TokenCName, PcdFromModule.TokenSpaceGuidCName) in self.Platform.Pcds\r
+\r
+ if PcdFromModule.Type in PCD_DYNAMIC_TYPE_SET or PcdFromModule.Type in PCD_DYNAMIC_EX_TYPE_SET:\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
# 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
+ if PcdFromModule.Type in PCD_DYNAMIC_TYPE_SET and \\r
PcdFromModule.IsFromBinaryInf == False:\r
# Print warning message to let the developer make a determine.\r
continue\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.Type in PCD_DYNAMIC_EX_TYPE_SET:\r
continue\r
#\r
# If a dynamic PCD used by a PEM module/PEI module & DXE module,\r
# used by DXE module, it should be stored in DXE PCD database.\r
# The default Phase is DXE\r
#\r
- if M.ModuleType in ["PEIM", "PEI_CORE"]:\r
+ if M.ModuleType in SUP_MODULE_SET_PEI:\r
PcdFromModule.Phase = "PEI"\r
if PcdFromModule not in self._DynaPcdList_:\r
self._DynaPcdList_.append(PcdFromModule)\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
+ DscModuleSet = {os.path.normpath(ModuleInf.Path) for ModuleInf in self.Platform.Modules}\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
+ if InfName not in DscModuleSet:\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
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
+ if PcdFromModule.Type not in PCD_DYNAMIC_EX_TYPE_SET 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
+ if PcdFromModule.DatumType == TAB_VOID and not PcdFromModule.MaxDatumSize:\r
NoDatumTypePcdList.add("%s.%s [%s]" % (PcdFromModule.TokenSpaceGuidCName, PcdFromModule.TokenCName, InfName))\r
- if M.ModuleType in ["PEIM", "PEI_CORE"]:\r
+ if M.ModuleType in SUP_MODULE_SET_PEI:\r
PcdFromModule.Phase = "PEI"\r
- if PcdFromModule not in self._DynaPcdList_ and PcdFromModule.Type in GenC.gDynamicExPcd:\r
+ if PcdFromModule not in self._DynaPcdList_ and PcdFromModule.Type in PCD_DYNAMIC_EX_TYPE_SET:\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
+ if PcdFromModule in self._DynaPcdList_ and PcdFromModule.Phase == 'PEI' and PcdFromModule.Type in PCD_DYNAMIC_EX_TYPE_SET:\r
# Overwrite the phase of any the same PCD existing, if Phase is PEI.\r
# It is to solve the case that a dynamic PCD used by a PEM module/PEI \r
# module & DXE module at a same time.\r
VpdFile = VpdInfoFile.VpdInfoFile()\r
NeedProcessVpdMapFile = False\r
\r
- for pcd in self.Platform.Pcds.keys():\r
- if pcd not in self._PlatformPcds.keys():\r
+ for pcd in self.Platform.Pcds:\r
+ if pcd not in self._PlatformPcds:\r
self._PlatformPcds[pcd] = self.Platform.Pcds[pcd]\r
\r
for item in self._PlatformPcds:\r
if self._PlatformPcds[item].DatumType and self._PlatformPcds[item].DatumType not in [TAB_UINT8, TAB_UINT16, TAB_UINT32, TAB_UINT64, TAB_VOID, "BOOLEAN"]:\r
- self._PlatformPcds[item].DatumType = "VOID*"\r
+ self._PlatformPcds[item].DatumType = TAB_VOID\r
\r
if (self.Workspace.ArchList[-1] == self.Arch): \r
for Pcd in self._DynamicPcdList:\r
# just pick the a value to determine whether is unicode string type\r
- Sku = Pcd.SkuInfoList[Pcd.SkuInfoList.keys()[0]]\r
+ Sku = Pcd.SkuInfoList.values()[0]\r
Sku.VpdOffset = Sku.VpdOffset.strip()\r
\r
if Pcd.DatumType not in [TAB_UINT8, TAB_UINT16, TAB_UINT32, TAB_UINT64, TAB_VOID, "BOOLEAN"]:\r
- Pcd.DatumType = "VOID*"\r
+ Pcd.DatumType = TAB_VOID\r
\r
# if found PCD which datum value is unicode string the insert to left size of UnicodeIndex\r
# if found HII type PCD then insert to right of UnicodeIndex\r
PcdKey in VpdPcdDict:\r
Pcd = VpdPcdDict[PcdKey]\r
SkuValueMap = {}\r
- DefaultSku = Pcd.SkuInfoList.get('DEFAULT')\r
+ DefaultSku = Pcd.SkuInfoList.get(TAB_DEFAULT)\r
if DefaultSku:\r
PcdValue = DefaultSku.DefaultValue\r
if PcdValue not in SkuValueMap:\r
SkuValueMap[PcdValue] = []\r
- VpdFile.Add(Pcd, '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
if DscPcdEntry.Type in [TAB_PCDS_DYNAMIC_VPD, TAB_PCDS_DYNAMIC_EX_VPD]:\r
if not (self.Platform.VpdToolGuid is None or self.Platform.VpdToolGuid == ''):\r
FoundFlag = False\r
- for VpdPcd in VpdFile._VpdArray.keys():\r
+ for VpdPcd in VpdFile._VpdArray:\r
# This PCD has been referenced by module\r
if (VpdPcd.TokenSpaceGuidCName == DscPcdEntry.TokenSpaceGuidCName) and \\r
(VpdPcd.TokenCName == DscPcdEntry.TokenCName):\r
# just pick the a value to determine whether is unicode string type\r
SkuValueMap = {}\r
SkuObjList = DscPcdEntry.SkuInfoList.items()\r
- DefaultSku = DscPcdEntry.SkuInfoList.get('DEFAULT')\r
+ DefaultSku = DscPcdEntry.SkuInfoList.get(TAB_DEFAULT)\r
if DefaultSku:\r
- defaultindex = SkuObjList.index(('DEFAULT',DefaultSku))\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
DscPcdEntry.TokenValue = DecPcdEntry.TokenValue\r
DscPcdEntry.TokenSpaceGuidValue = eachDec.Guids[DecPcdEntry.TokenSpaceGuidCName]\r
# Only fix the value while no value provided in DSC file.\r
- if (Sku.DefaultValue == "" or Sku.DefaultValue==None):\r
+ if not Sku.DefaultValue:\r
DscPcdEntry.SkuInfoList[DscPcdEntry.SkuInfoList.keys()[0]].DefaultValue = DecPcdEntry.DefaultValue\r
\r
if DscPcdEntry not in self._DynamicPcdList:\r
SkuValueMap[PcdValue].append(Sku)\r
if not NeedProcessVpdMapFile and Sku.VpdOffset == "*":\r
NeedProcessVpdMapFile = True \r
- if DscPcdEntry.DatumType == 'VOID*' and PcdValue.startswith("L"):\r
+ if DscPcdEntry.DatumType == TAB_VOID and PcdValue.startswith("L"):\r
UnicodePcdArray.add(DscPcdEntry)\r
elif len(Sku.VariableName) > 0:\r
HiiPcdArray.add(DscPcdEntry)\r
\r
# Process VPD map file generated by third party BPDG tool\r
if NeedProcessVpdMapFile:\r
- VpdMapFilePath = os.path.join(self.BuildDir, "FV", "%s.map" % self.Platform.VpdToolGuid)\r
+ VpdMapFilePath = os.path.join(self.BuildDir, TAB_FV_DIRECTORY, "%s.map" % self.Platform.VpdToolGuid)\r
if os.path.exists(VpdMapFilePath):\r
VpdFile.Read(VpdMapFilePath)\r
\r
# Delete the DynamicPcdList At the last time enter into this function\r
for Pcd in self._DynamicPcdList:\r
# just pick the a value to determine whether is unicode string type\r
- Sku = Pcd.SkuInfoList[Pcd.SkuInfoList.keys()[0]]\r
+ Sku = Pcd.SkuInfoList.values()[0]\r
Sku.VpdOffset = Sku.VpdOffset.strip()\r
\r
if Pcd.DatumType not in [TAB_UINT8, TAB_UINT16, TAB_UINT32, TAB_UINT64, TAB_VOID, "BOOLEAN"]:\r
- Pcd.DatumType = "VOID*"\r
+ Pcd.DatumType = TAB_VOID\r
\r
PcdValue = Sku.DefaultValue\r
- if Pcd.DatumType == 'VOID*' and PcdValue.startswith("L"):\r
+ if Pcd.DatumType == TAB_VOID and PcdValue.startswith("L"):\r
# if found PCD which datum value is unicode string the insert to left size of UnicodeIndex\r
UnicodePcdArray.add(Pcd)\r
elif len(Sku.VariableName) > 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['DEFAULT'])\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
- FvPath = os.path.join(self.BuildDir, "FV")\r
+ FvPath = os.path.join(self.BuildDir, TAB_FV_DIRECTORY)\r
if not os.path.exists(FvPath):\r
try:\r
os.makedirs(FvPath)\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("GUID") and ToolDef["GUID"] == self.Platform.VpdToolGuid:\r
+ if ToolDef.has_key(TAB_GUID) and ToolDef[TAB_GUID] == self.Platform.VpdToolGuid:\r
if not ToolDef.has_key("PATH"):\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
BuildRuleFile = None\r
if TAB_TAT_DEFINES_BUILD_RULE_CONF in self.Workspace.TargetTxt.TargetTxtDictionary:\r
BuildRuleFile = self.Workspace.TargetTxt.TargetTxtDictionary[TAB_TAT_DEFINES_BUILD_RULE_CONF]\r
- if BuildRuleFile in [None, '']:\r
+ if not BuildRuleFile:\r
BuildRuleFile = gDefaultBuildRuleFile\r
self._BuildRule = BuildRule(BuildRuleFile)\r
if self._BuildRule._FileVersion == "":\r
#\r
for Pcd in self.DynamicPcdList:\r
if Pcd.Phase == "PEI":\r
- if Pcd.Type in ["Dynamic", "DynamicDefault", "DynamicVpd", "DynamicHii"]:\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
\r
for Pcd in self.DynamicPcdList:\r
if Pcd.Phase == "PEI":\r
- if Pcd.Type in ["DynamicEx", "DynamicExDefault", "DynamicExVpd", "DynamicExHii"]:\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
\r
for Pcd in self.DynamicPcdList:\r
if Pcd.Phase == "DXE":\r
- if Pcd.Type in ["Dynamic", "DynamicDefault", "DynamicVpd", "DynamicHii"]:\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
\r
for Pcd in self.DynamicPcdList:\r
if Pcd.Phase == "DXE":\r
- if Pcd.Type in ["DynamicEx", "DynamicExDefault", "DynamicExVpd", "DynamicExHii"]:\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
LibraryModule.LibraryClass.append(LibraryClassObject(LibraryClassName, [ModuleType]))\r
elif LibraryModule.LibraryClass is None \\r
or len(LibraryModule.LibraryClass) == 0 \\r
- or (ModuleType != 'USER_DEFINED'\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
#\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
+ 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
# @param ToPcd The PCD to be overrided\r
# @param FromPcd The PCD overrideing from\r
#\r
- def _OverridePcd(self, ToPcd, FromPcd, Module=""):\r
+ def _OverridePcd(self, ToPcd, FromPcd, Module="", Msg="", Library=""):\r
#\r
# in case there's PCDs coming from FDF file, which have no type given.\r
# at this point, ToPcd.Type has the type found from dependent\r
TokenCName = PcdItem[0]\r
break\r
if FromPcd is not None:\r
- if ToPcd.Pending and FromPcd.Type not in [None, '']:\r
+ if ToPcd.Pending and FromPcd.Type:\r
ToPcd.Type = FromPcd.Type\r
- elif (ToPcd.Type not in [None, '']) and (FromPcd.Type not in [None, ''])\\r
+ elif (ToPcd.Type) and (FromPcd.Type)\\r
and (ToPcd.Type != FromPcd.Type) and (ToPcd.Type in FromPcd.Type):\r
- if ToPcd.Type.strip() == "DynamicEx":\r
+ if ToPcd.Type.strip() == TAB_PCDS_DYNAMIC_EX:\r
ToPcd.Type = FromPcd.Type\r
- elif ToPcd.Type not in [None, ''] and FromPcd.Type not in [None, ''] \\r
+ elif ToPcd.Type and FromPcd.Type \\r
and ToPcd.Type != FromPcd.Type:\r
+ if Library:\r
+ Module = str(Module) + " 's library file (" + str(Library) + ")"\r
EdkLogger.error("build", OPTION_CONFLICT, "Mismatched PCD type",\r
- ExtraData="%s.%s is defined as [%s] in module %s, but as [%s] in platform."\\r
+ ExtraData="%s.%s is used as [%s] in module %s, but as [%s] in %s."\\r
% (ToPcd.TokenSpaceGuidCName, TokenCName,\r
- ToPcd.Type, Module, FromPcd.Type),\r
+ ToPcd.Type, Module, FromPcd.Type, Msg),\r
File=self.MetaFile)\r
\r
if FromPcd.MaxDatumSize:\r
ToPcd.validlists = FromPcd.validlists\r
ToPcd.expressions = FromPcd.expressions\r
\r
- if FromPcd is not None and ToPcd.DatumType == "VOID*" and ToPcd.MaxDatumSize in ['', None]:\r
+ if FromPcd is not None and ToPcd.DatumType == TAB_VOID and not ToPcd.MaxDatumSize:\r
EdkLogger.debug(EdkLogger.DEBUG_9, "No MaxDatumSize specified for PCD %s.%s" \\r
% (ToPcd.TokenSpaceGuidCName, TokenCName))\r
Value = ToPcd.DefaultValue\r
- if Value in [None, '']:\r
+ if not Value:\r
ToPcd.MaxDatumSize = '1'\r
elif Value[0] == 'L':\r
ToPcd.MaxDatumSize = str((len(Value) - 2) * 2)\r
ToPcd.MaxDatumSize = str(len(Value) - 1)\r
\r
# apply default SKU for dynamic PCDS if specified one is not available\r
- if (ToPcd.Type in PCD_DYNAMIC_TYPE_LIST or ToPcd.Type in PCD_DYNAMIC_EX_TYPE_LIST) \\r
- and ToPcd.SkuInfoList in [None, {}, '']:\r
+ if (ToPcd.Type in PCD_DYNAMIC_TYPE_SET or ToPcd.Type in PCD_DYNAMIC_EX_TYPE_SET) \\r
+ and not ToPcd.SkuInfoList:\r
if self.Platform.SkuName in self.Platform.SkuIds:\r
SkuName = self.Platform.SkuName\r
else:\r
- SkuName = 'DEFAULT'\r
+ SkuName = TAB_DEFAULT\r
ToPcd.SkuInfoList = {\r
SkuName : SkuInfoClass(SkuName, self.Platform.SkuIds[SkuName][0], '', '', '', '', '', ToPcd.DefaultValue)\r
}\r
#\r
# @retval PCD_list The list PCDs with settings from platform\r
#\r
- def ApplyPcdSetting(self, Module, Pcds):\r
+ def ApplyPcdSetting(self, Module, Pcds, Library=""):\r
# for each PCD in module\r
for Name, Guid in Pcds:\r
PcdInModule = Pcds[Name, Guid]\r
else:\r
PcdInPlatform = None\r
# then override the settings if any\r
- self._OverridePcd(PcdInModule, PcdInPlatform, Module)\r
+ self._OverridePcd(PcdInModule, PcdInPlatform, Module, Msg="DSC PCD sections", Library=Library)\r
# resolve the VariableGuid value\r
for SkuId in PcdInModule.SkuInfoList:\r
Sku = PcdInModule.SkuInfoList[SkuId]\r
if Sku.VariableGuid == '': continue\r
Sku.VariableGuidValue = GuidValue(Sku.VariableGuid, self.PackageList, self.MetaFile.Path)\r
if Sku.VariableGuidValue is None:\r
- PackageList = "\n\t".join([str(P) for P in self.PackageList])\r
+ PackageList = "\n\t".join(str(P) for P in self.PackageList)\r
EdkLogger.error(\r
'build',\r
RESOURCE_NOT_AVAILABLE,\r
Flag = True\r
break\r
if Flag:\r
- self._OverridePcd(ToPcd, PlatformModule.Pcds[Key], Module)\r
+ self._OverridePcd(ToPcd, PlatformModule.Pcds[Key], Module, Msg="DSC Components Module scoped PCD section", Library=Library)\r
# use PCD value to calculate the MaxDatumSize when it is not specified\r
for Name, Guid in Pcds:\r
Pcd = Pcds[Name, Guid]\r
- if Pcd.DatumType == "VOID*" and Pcd.MaxDatumSize in ['', None]:\r
+ if Pcd.DatumType == TAB_VOID and not Pcd.MaxDatumSize:\r
Pcd.MaxSizeUserSet = None\r
Value = Pcd.DefaultValue\r
- if Value in [None, '']:\r
+ if not Value:\r
Pcd.MaxDatumSize = '1'\r
elif Value[0] == 'L':\r
Pcd.MaxDatumSize = str((len(Value) - 2) * 2)\r
for LibraryName in M.Libraries:\r
Library = self.Platform.LibraryClasses[LibraryName, ':dummy:']\r
if Library is None:\r
- for Key in self.Platform.LibraryClasses.data.keys():\r
+ for Key in self.Platform.LibraryClasses.data:\r
if LibraryName.upper() == Key.upper():\r
Library = self.Platform.LibraryClasses[Key, ':dummy:']\r
break\r
if self._FixedAtBuildPcds:\r
return self._FixedAtBuildPcds\r
for Pcd in self.ModulePcdList:\r
- if Pcd.Type != "FixedAtBuild":\r
+ if Pcd.Type != TAB_PCDS_FIXED_AT_BUILD:\r
continue\r
if Pcd not in self._FixedAtBuildPcds:\r
self._FixedAtBuildPcds.append(Pcd)\r
def _GetFfsOutputDir(self):\r
if self._FfsOutputDir is None:\r
if GlobalData.gFdfParser is not None:\r
- self._FfsOutputDir = path.join(self.PlatformInfo.BuildDir, "FV", "Ffs", self.Guid + self.Name)\r
+ self._FfsOutputDir = path.join(self.PlatformInfo.BuildDir, TAB_FV_DIRECTORY, "Ffs", self.Guid + self.Name)\r
else:\r
self._FfsOutputDir = ''\r
return self._FfsOutputDir\r
InfObj = InfSectionParser.InfSectionParser(Filename)\r
DepexExpresionList = InfObj.GetDepexExpresionList()\r
for DepexExpresion in DepexExpresionList:\r
- for key in DepexExpresion.keys():\r
+ for key in DepexExpresion:\r
Arch, ModuleType = key\r
DepexExpr = [x for x in DepexExpresion[key] if not str(x).startswith('#')]\r
# the type of build module is USER_DEFINED.\r
#the type of build module is USER_DEFINED.\r
if self.ModuleType.upper() == SUP_MODULE_USER_DEFINED:\r
for Depex in DepexList:\r
- for key in Depex.keys():\r
+ for key in Depex:\r
DepexStr += '[Depex.%s.%s]\n' % key\r
- DepexStr += '\n'.join(['# '+ val for val in Depex[key]])\r
+ DepexStr += '\n'.join('# '+ val for val in Depex[key])\r
DepexStr += '\n\n'\r
if not DepexStr:\r
return '[Depex.%s]\n' % self.Arch\r
DepexStr += ' AND '\r
DepexStr += '('\r
for D in Depex.values():\r
- DepexStr += ' '.join([val for val in D])\r
+ DepexStr += ' '.join(val for val in D)\r
Index = DepexStr.find('END')\r
if Index > -1 and Index == len(DepexStr) - 3:\r
DepexStr = DepexStr[:-3]\r
InfObj = InfSectionParser.InfSectionParser(Filename)\r
TianoCoreUserExtenList = InfObj.GetUserExtensionTianoCore()\r
for TianoCoreUserExtent in TianoCoreUserExtenList:\r
- for Section in TianoCoreUserExtent.keys():\r
+ for Section in TianoCoreUserExtent:\r
ItemList = Section.split(TAB_SPLIT)\r
Arch = self.Arch\r
if len(ItemList) == 4:\r
if self._BinaryFileList is None:\r
self._BinaryFileList = []\r
for F in self.Module.Binaries:\r
- if F.Target not in ['COMMON', '*'] and F.Target != self.BuildTarget:\r
+ if F.Target not in [TAB_ARCH_COMMON, '*'] and F.Target != self.BuildTarget:\r
continue\r
self._BinaryFileList.append(F)\r
self._ApplyBuildRule(F, F.Type)\r
Pcds = OrderedDict()\r
if not self.IsLibrary:\r
# get PCDs from dependent libraries\r
+ self._LibraryPcdList = []\r
for Library in self.DependentLibraryList:\r
+ PcdsInLibrary = OrderedDict()\r
self.UpdateComments(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
continue\r
Pcds[Key] = copy.copy(Library.Pcds[Key])\r
- # apply PCD settings from platform\r
- self._LibraryPcdList = self.PlatformInfo.ApplyPcdSetting(self.Module, Pcds)\r
+ PcdsInLibrary[Key] = Pcds[Key]\r
+ self._LibraryPcdList.extend(self.PlatformInfo.ApplyPcdSetting(self.Module, PcdsInLibrary, Library=Library))\r
else:\r
self._LibraryPcdList = []\r
return self._LibraryPcdList\r
return\r
\r
# Skip the following code for modules without any binary files\r
- if not self.BinaryFileList:\r
+ if self.BinaryFileList:\r
return\r
\r
### TODO: How to handles mixed source and binary modules\r
for Pcd in self.ModulePcdList + self.LibraryPcdList:\r
if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:\r
PatchablePcds += [Pcd]\r
- PcdCheckList.append((Pcd.TokenCName, Pcd.TokenSpaceGuidCName, 'PatchableInModule'))\r
- elif Pcd.Type in GenC.gDynamicExPcd:\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
- PcdCheckList.append((Pcd.TokenCName, Pcd.TokenSpaceGuidCName, 'DynamicEx'))\r
- PcdCheckList.append((Pcd.TokenCName, Pcd.TokenSpaceGuidCName, 'Dynamic'))\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
GuidList = OrderedDict()\r
GuidList.update(self.GuidList)\r
if Pkg in Packages:\r
continue\r
for VfrPcd in VfrPcds:\r
- if ((VfrPcd.TokenCName, VfrPcd.TokenSpaceGuidCName, 'DynamicEx') in Pkg.Pcds or\r
- (VfrPcd.TokenCName, VfrPcd.TokenSpaceGuidCName, 'Dynamic') in Pkg.Pcds):\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
break\r
\r
ModuleType = self.ModuleType\r
- if ModuleType == 'UEFI_DRIVER' and self.DepexGenerated:\r
- ModuleType = 'DXE_DRIVER'\r
+ if ModuleType == SUP_MODULE_UEFI_DRIVER and self.DepexGenerated:\r
+ ModuleType = SUP_MODULE_DXE_DRIVER\r
\r
DriverType = ''\r
if self.PcdIsDriver != '':\r
AsBuiltInfDict['binary_item'] += ['BIN|' + File]\r
if self.DepexGenerated:\r
self.OutputFile.add(self.Name + '.depex')\r
- if self.ModuleType in ['PEIM']:\r
+ if self.ModuleType in [SUP_MODULE_PEIM]:\r
AsBuiltInfDict['binary_item'] += ['PEI_DEPEX|' + self.Name + '.depex']\r
- if self.ModuleType in ['DXE_DRIVER', 'DXE_RUNTIME_DRIVER', 'DXE_SAL_DRIVER', 'UEFI_DRIVER']:\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 ['DXE_SMM_DRIVER']:\r
+ if self.ModuleType in [SUP_MODULE_DXE_SMM_DRIVER]:\r
AsBuiltInfDict['binary_item'] += ['SMM_DEPEX|' + self.Name + '.depex']\r
\r
Bin = self._GenOffsetBin()\r
elif BoolValue == 'FALSE':\r
Pcd.DefaultValue = '0'\r
\r
- if Pcd.DatumType in ['UINT8', 'UINT16', 'UINT32', 'UINT64', 'BOOLEAN']:\r
+ if Pcd.DatumType in TAB_PCD_NUMERIC_TYPES:\r
HexFormat = '0x%02x'\r
- if Pcd.DatumType == 'UINT16':\r
+ if Pcd.DatumType == TAB_UINT16:\r
HexFormat = '0x%04x'\r
- elif Pcd.DatumType == 'UINT32':\r
+ elif Pcd.DatumType == TAB_UINT32:\r
HexFormat = '0x%08x'\r
- elif Pcd.DatumType == 'UINT64':\r
+ elif Pcd.DatumType == TAB_UINT64:\r
HexFormat = '0x%016x'\r
PcdValue = HexFormat % int(Pcd.DefaultValue, 0)\r
else:\r
return\r
\r
for ModuleType in self.DepexList:\r
- # Ignore empty [depex] section or [depex] section for "USER_DEFINED" module\r
- if len(self.DepexList[ModuleType]) == 0 or ModuleType == "USER_DEFINED":\r
+ # Ignore empty [depex] section or [depex] section for SUP_MODULE_USER_DEFINED module\r
+ if len(self.DepexList[ModuleType]) == 0 or ModuleType == SUP_MODULE_USER_DEFINED:\r
continue\r
\r
Dpx = GenDepex.DependencyExpression(self.DepexList[ModuleType], ModuleType, True)\r
m.update(GlobalData.gPlatformHash)\r
# Add Package level hash\r
if self.DependentPackageList:\r
- for Pkg in self.DependentPackageList:\r
+ for Pkg in sorted(self.DependentPackageList, key=lambda x: x.PackageName):\r
if Pkg.PackageName in GlobalData.gPackageHash[self.Arch]:\r
m.update(GlobalData.gPackageHash[self.Arch][Pkg.PackageName])\r
\r
# Add Library hash\r
if self.LibraryAutoGenList:\r
- for Lib in self.LibraryAutoGenList:\r
+ for Lib in sorted(self.LibraryAutoGenList, key=lambda x: x.Name):\r
if Lib.Name not in GlobalData.gModuleHash[self.Arch]:\r
Lib.GenModuleHash()\r
m.update(GlobalData.gModuleHash[self.Arch][Lib.Name])\r
m.update(Content)\r
# Add Module's source files\r
if self.SourceFileList:\r
- for File in self.SourceFileList:\r
+ for File in sorted(self.SourceFileList, key=lambda x: str(x)):\r
f = open(str(File), 'r')\r
Content = f.read()\r
f.close()\r