import Common.VpdInfoFile as VpdInfoFile\r
from GenPcdDb import CreatePcdDatabaseCode\r
from Workspace.MetaFileCommentParser import UsageList\r
-\r
+from Common.MultipleWorkspace import MultipleWorkspace as mws\r
import InfSectionParser\r
\r
## Regular expression for splitting Dependency Expression string into tokens\r
# @param SkuId SKU id from command line\r
#\r
def _Init(self, WorkspaceDir, ActivePlatform, Target, Toolchain, ArchList, MetaFileDb,\r
- BuildConfig, ToolDefinition, FlashDefinitionFile='', Fds=None, Fvs=None, Caps=None, SkuId='', UniFlag=None, \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
\r
# Validate build target\r
if self.BuildTarget not in self.Platform.BuildTargets:\r
- EdkLogger.error("build", PARAMETER_INVALID, \r
+ EdkLogger.error("build", PARAMETER_INVALID,\r
ExtraData="Build target [%s] is not supported by the platform. [Valid target: %s]"\r
% (self.BuildTarget, " ".join(self.Platform.BuildTargets)))\r
\r
# parse FDF file to get PCDs in it, if any\r
if not self.FdfFile:\r
self.FdfFile = self.Platform.FlashDefinition\r
- \r
+\r
EdkLogger.info("")\r
if self.ArchList:\r
EdkLogger.info('%-16s = %s' % ("Architecture(s)", ' '.join(self.ArchList)))\r
EdkLogger.info('%-16s = %s' % ("Build target", self.BuildTarget))\r
- EdkLogger.info('%-16s = %s' % ("Toolchain",self.ToolChain)) \r
- \r
+ EdkLogger.info('%-16s = %s' % ("Toolchain", self.ToolChain))\r
+\r
EdkLogger.info('\n%-24s = %s' % ("Active Platform", self.Platform))\r
if BuildModule:\r
EdkLogger.info('%-24s = %s' % ("Active Module", BuildModule))\r
- \r
+\r
if self.FdfFile:\r
EdkLogger.info('%-24s = %s' % ("Flash Image Definition", self.FdfFile))\r
\r
EdkLogger.verbose("\nFLASH_DEFINITION = %s" % self.FdfFile)\r
- \r
+\r
if Progress:\r
Progress.Start("\nProcessing meta-data")\r
- \r
+\r
if self.FdfFile:\r
#\r
# Mark now build in AutoGen Phase\r
#\r
- GlobalData.gAutoGenPhase = True \r
+ GlobalData.gAutoGenPhase = True\r
Fdf = FdfParser(self.FdfFile.Path)\r
Fdf.ParseFile()\r
GlobalData.gFdfParser = Fdf\r
if self.CapTargetList:\r
EdkLogger.info("No flash definition file found. Capsule [%s] will be ignored." % " ".join(self.CapTargetList))\r
self.CapTargetList = []\r
- \r
+\r
# apply SKU and inject PCDs from Flash Definition file\r
for Arch in self.ArchList:\r
Platform = self.BuildDatabase[self.MetaFile, Arch, Target, Toolchain]\r
Pa.CollectPlatformDynamicPcds()\r
Pa.CollectFixedAtBuildPcds()\r
self.AutoGenObjectList.append(Pa)\r
- \r
+\r
#\r
# Check PCDs token value conflict in each DEC file.\r
#\r
self._CheckAllPcdsTokenValueConflict()\r
- \r
+\r
#\r
# Check PCD type and definition between DSC and DEC\r
#\r
#\r
# Get INF file GUID\r
#\r
- InfFoundFlag = False \r
+ InfFoundFlag = False\r
for Pa in self.AutoGenObjectList:\r
if InfFoundFlag:\r
break\r
_GuidDict[Module.Guid.upper()] = FfsFile\r
break\r
else:\r
- EdkLogger.error("build", \r
+ EdkLogger.error("build",\r
FORMAT_INVALID,\r
- "Duplicate GUID found for these lines: Line %d: %s and Line %d: %s. GUID: %s"%(FfsFile.CurrentLineNum,\r
+ "Duplicate GUID found for these lines: Line %d: %s and Line %d: %s. GUID: %s" % (FfsFile.CurrentLineNum,\r
FfsFile.CurrentLineContent,\r
_GuidDict[Module.Guid.upper()].CurrentLineNum,\r
_GuidDict[Module.Guid.upper()].CurrentLineContent,\r
InfPath = NormPath(FfsFile.InfFileName)\r
if not os.path.exists(InfPath):\r
EdkLogger.error('build', GENFDS_ERROR, "Non-existant Module %s !" % (FfsFile.InfFileName))\r
- \r
+\r
PathClassObj = PathClass(FfsFile.InfFileName, self.WorkspaceDir)\r
#\r
# Here we just need to get FILE_GUID from INF file, use 'COMMON' as ARCH attribute. and use \r
if not InfObj.Guid.upper() in _GuidDict.keys():\r
_GuidDict[InfObj.Guid.upper()] = FfsFile\r
else:\r
- EdkLogger.error("build", \r
+ EdkLogger.error("build",\r
FORMAT_INVALID,\r
- "Duplicate GUID found for these lines: Line %d: %s and Line %d: %s. GUID: %s"%(FfsFile.CurrentLineNum,\r
+ "Duplicate GUID found for these lines: Line %d: %s and Line %d: %s. GUID: %s" % (FfsFile.CurrentLineNum,\r
FfsFile.CurrentLineContent,\r
_GuidDict[InfObj.Guid.upper()].CurrentLineNum,\r
_GuidDict[InfObj.Guid.upper()].CurrentLineContent,\r
InfObj.Guid.upper()),\r
ExtraData=self.FdfFile)\r
InfFoundFlag = False\r
- \r
+\r
if FfsFile.NameGuid != None:\r
_CheckPCDAsGuidPattern = re.compile("^PCD\(.+\..+\)$")\r
- \r
+\r
#\r
# If the NameGuid reference a PCD name. \r
# The style must match: PCD(xxxx.yyy)\r
# First convert from CFormatGuid to GUID string\r
#\r
_PcdGuidString = GuidStructureStringToGuidString(PcdItem.DefaultValue)\r
- \r
+\r
if not _PcdGuidString:\r
#\r
# Then try Byte array.\r
#\r
_PcdGuidString = GuidStructureByteArrayToGuidString(PcdItem.DefaultValue)\r
- \r
+\r
if not _PcdGuidString:\r
#\r
# Not Byte array or CFormat GUID, raise error.\r
#\r
EdkLogger.error("build",\r
FORMAT_INVALID,\r
- "The format of PCD value is incorrect. PCD: %s , Value: %s\n"%(_PcdName, PcdItem.DefaultValue),\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
+\r
+ if not _PcdGuidString.upper() in _GuidDict.keys():\r
_GuidDict[_PcdGuidString.upper()] = FfsFile\r
PcdFoundFlag = True\r
break\r
else:\r
- EdkLogger.error("build", \r
+ EdkLogger.error("build",\r
FORMAT_INVALID,\r
- "Duplicate GUID found for these lines: Line %d: %s and Line %d: %s. GUID: %s"%(FfsFile.CurrentLineNum,\r
+ "Duplicate GUID found for these lines: Line %d: %s and Line %d: %s. GUID: %s" % (FfsFile.CurrentLineNum,\r
FfsFile.CurrentLineContent,\r
_GuidDict[_PcdGuidString.upper()].CurrentLineNum,\r
_GuidDict[_PcdGuidString.upper()].CurrentLineContent,\r
FfsFile.NameGuid.upper()),\r
- ExtraData=self.FdfFile) \r
- \r
+ ExtraData=self.FdfFile)\r
+\r
if not FfsFile.NameGuid.upper() in _GuidDict.keys():\r
_GuidDict[FfsFile.NameGuid.upper()] = FfsFile\r
else:\r
#\r
# Two raw file GUID conflict.\r
#\r
- EdkLogger.error("build", \r
+ EdkLogger.error("build",\r
FORMAT_INVALID,\r
- "Duplicate GUID found for these lines: Line %d: %s and Line %d: %s. GUID: %s"%(FfsFile.CurrentLineNum,\r
+ "Duplicate GUID found for these lines: Line %d: %s and Line %d: %s. GUID: %s" % (FfsFile.CurrentLineNum,\r
FfsFile.CurrentLineContent,\r
_GuidDict[FfsFile.NameGuid.upper()].CurrentLineNum,\r
_GuidDict[FfsFile.NameGuid.upper()].CurrentLineContent,\r
FfsFile.NameGuid.upper()),\r
ExtraData=self.FdfFile)\r
- \r
+\r
\r
def _CheckPcdDefineAndType(self):\r
PcdTypeList = [\r
# Key of DSC's Pcds dictionary is PcdCName, TokenSpaceGuid\r
for Pcd in Pa.Platform.Pcds:\r
PcdType = Pa.Platform.Pcds[Pcd].Type\r
- \r
+\r
# If no PCD type, this PCD comes from FDF \r
if not PcdType:\r
continue\r
- \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
- \r
+\r
for Package in Pa.PackageList:\r
# Key of DEC's Pcds dictionary is PcdCName, TokenSpaceGuid, PcdType\r
if (Pcd[0], Pcd[1], PcdType) in Package.Pcds:\r
# BuildCommand should be all the same. So just get one from platform AutoGen\r
self._BuildCommand = self.AutoGenObjectList[0].BuildCommand\r
return self._BuildCommand\r
- \r
+\r
## Check the PCDs token value conflict in each DEC file.\r
#\r
# Will cause build break and raise error message while two PCDs conflict.\r
for Pa in self.AutoGenObjectList:\r
for Package in Pa.PackageList:\r
PcdList = Package.Pcds.values()\r
- PcdList.sort(lambda x, y: cmp(x.TokenValue, y.TokenValue)) \r
+ PcdList.sort(lambda x, y: cmp(int(x.TokenValue, 0), int(y.TokenValue, 0))) \r
Count = 0\r
while (Count < len(PcdList) - 1) :\r
Item = PcdList[Count]\r
#\r
# Make sure in the same token space the TokenValue should be unique\r
#\r
- if (Item.TokenValue == ItemNext.TokenValue):\r
+ if (int(Item.TokenValue, 0) == int(ItemNext.TokenValue, 0)):\r
SameTokenValuePcdList = []\r
SameTokenValuePcdList.append(Item)\r
SameTokenValuePcdList.append(ItemNext)\r
RemainPcdListLength = len(PcdList) - Count - 2\r
for ValueSameCount in range(RemainPcdListLength):\r
- if PcdList[len(PcdList) - RemainPcdListLength + ValueSameCount].TokenValue == Item.TokenValue:\r
+ if int(PcdList[len(PcdList) - RemainPcdListLength + ValueSameCount].TokenValue, 0) == int(Item.TokenValue, 0):\r
SameTokenValuePcdList.append(PcdList[len(PcdList) - RemainPcdListLength + ValueSameCount])\r
else:\r
break;\r
#\r
# Sort same token value PCD list with TokenGuid and TokenCName\r
#\r
- SameTokenValuePcdList.sort(lambda x, y: cmp("%s.%s"%(x.TokenSpaceGuidCName, x.TokenCName), "%s.%s"%(y.TokenSpaceGuidCName, y.TokenCName))) \r
- SameTokenValuePcdListCount = 0 \r
+ SameTokenValuePcdList.sort(lambda x, y: cmp("%s.%s" % (x.TokenSpaceGuidCName, x.TokenCName), "%s.%s" % (y.TokenSpaceGuidCName, y.TokenCName)))\r
+ SameTokenValuePcdListCount = 0\r
while (SameTokenValuePcdListCount < len(SameTokenValuePcdList) - 1):\r
- TemListItem = SameTokenValuePcdList[SameTokenValuePcdListCount]\r
- TemListItemNext = SameTokenValuePcdList[SameTokenValuePcdListCount + 1] \r
- \r
+ TemListItem = SameTokenValuePcdList[SameTokenValuePcdListCount]\r
+ TemListItemNext = SameTokenValuePcdList[SameTokenValuePcdListCount + 1]\r
+\r
if (TemListItem.TokenSpaceGuidCName == TemListItemNext.TokenSpaceGuidCName) and (TemListItem.TokenCName != TemListItemNext.TokenCName):\r
EdkLogger.error(\r
'build',\r
SameTokenValuePcdListCount += 1\r
Count += SameTokenValuePcdListCount\r
Count += 1\r
- \r
+\r
PcdList = Package.Pcds.values()\r
- PcdList.sort(lambda x, y: cmp("%s.%s"%(x.TokenSpaceGuidCName, x.TokenCName), "%s.%s"%(y.TokenSpaceGuidCName, y.TokenCName)))\r
+ PcdList.sort(lambda x, y: cmp("%s.%s" % (x.TokenSpaceGuidCName, x.TokenCName), "%s.%s" % (y.TokenSpaceGuidCName, y.TokenCName)))\r
Count = 0\r
while (Count < len(PcdList) - 1) :\r
Item = PcdList[Count]\r
- ItemNext = PcdList[Count + 1] \r
+ ItemNext = PcdList[Count + 1]\r
#\r
# Check PCDs with same TokenSpaceGuidCName.TokenCName have same token value as well.\r
#\r
- if (Item.TokenSpaceGuidCName == ItemNext.TokenSpaceGuidCName) and (Item.TokenCName == ItemNext.TokenCName) and (Item.TokenValue != ItemNext.TokenValue):\r
+ if (Item.TokenSpaceGuidCName == ItemNext.TokenSpaceGuidCName) and (Item.TokenCName == ItemNext.TokenCName) and (int(Item.TokenValue, 0) != int(ItemNext.TokenValue, 0)):\r
EdkLogger.error(\r
'build',\r
FORMAT_INVALID,\r
"0x01001" : 3, # ******_TOOLCHAIN_****_***********_ATTRIBUTE\r
"0x10001" : 2, # TARGET_*********_****_***********_ATTRIBUTE\r
"0x00001" : 1} # ******_*********_****_***********_ATTRIBUTE (Lowest)\r
- \r
+\r
## The real constructor of PlatformAutoGen\r
#\r
# This method is not supposed to be called by users of PlatformAutoGen. It's\r
self._GuidValue = {}\r
FdfModuleList = []\r
for InfName in self._AsBuildInfList:\r
- InfName = os.path.join(self.WorkspaceDir, InfName)\r
+ InfName = mws.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
\r
self.Platform.Modules[F].M = M\r
- \r
- for PcdFromModule in M.ModulePcdList+M.LibraryPcdList:\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
NoDatumTypePcdList.add("%s.%s [%s]" % (PcdFromModule.TokenSpaceGuidCName, PcdFromModule.TokenCName, F))\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[Pcd.SkuInfoList.keys()[0]]\r
Sku.VpdOffset = Sku.VpdOffset.strip()\r
- \r
+\r
PcdValue = Sku.DefaultValue\r
if Pcd.DatumType == 'VOID*' and PcdValue.startswith("L"):\r
# if found PCD which datum value is unicode string the insert to left size of UnicodeIndex\r
else:\r
OtherPcdArray.append(Pcd)\r
if Pcd.Type in [TAB_PCDS_DYNAMIC_VPD, TAB_PCDS_DYNAMIC_EX_VPD]:\r
- VpdPcdDict[(Pcd.TokenCName, Pcd.TokenSpaceGuidCName)] = Pcd \r
- \r
+ VpdPcdDict[(Pcd.TokenCName, Pcd.TokenSpaceGuidCName)] = Pcd\r
+\r
PlatformPcds = self.Platform.Pcds.keys()\r
- PlatformPcds.sort() \r
+ PlatformPcds.sort()\r
#\r
# Add VPD type PCD into VpdFile and determine whether the VPD PCD need to be fixed up.\r
#\r
if self.Platform.VpdToolGuid == None or self.Platform.VpdToolGuid == '':\r
EdkLogger.error("Build", FILE_NOT_FOUND, \\r
"Fail to find third-party BPDG tool to process VPD PCDs. BPDG Guid tool need to be defined in tools_def.txt and VPD_TOOL_GUID need to be provided in DSC file.")\r
- \r
- \r
+\r
+\r
#\r
# Fix the PCDs define in VPD PCD section that never referenced by module.\r
# An example is PCD for signature usage.\r
if (VpdPcd.TokenSpaceGuidCName == DscPcdEntry.TokenSpaceGuidCName) and \\r
(VpdPcd.TokenCName == DscPcdEntry.TokenCName):\r
FoundFlag = True\r
- \r
+\r
# Not found, it should be signature\r
if not FoundFlag :\r
# just pick the a value to determine whether is unicode string type\r
VpdFile.GetCount() != 0:\r
EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, \r
"Fail to get FLASH_DEFINITION definition in DSC file %s which is required when DSC contains VPD PCD." % str(self.Platform.MetaFile))\r
- \r
+\r
if VpdFile.GetCount() != 0:\r
DscTimeStamp = self.Platform.MetaFile.TimeStamp\r
FvPath = os.path.join(self.BuildDir, "FV")\r
os.makedirs(FvPath)\r
except:\r
EdkLogger.error("build", FILE_WRITE_FAILURE, "Fail to create FV folder under %s" % self.BuildDir)\r
- \r
- \r
+\r
+\r
VpdFilePath = os.path.join(FvPath, "%s.txt" % self.Platform.VpdToolGuid)\r
\r
- \r
+\r
if not os.path.exists(VpdFilePath) or os.path.getmtime(VpdFilePath) < DscTimeStamp:\r
VpdFile.Write(VpdFilePath)\r
- \r
+\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
VpdInfoFile.CallExtenalBPDGTool(BPDGToolName, VpdFilePath)\r
else:\r
EdkLogger.error("Build", FILE_NOT_FOUND, "Fail to find third-party BPDG tool to process VPD PCDs. BPDG Guid tool need to be defined in tools_def.txt and VPD_TOOL_GUID need to be provided in DSC file.")\r
- \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
if os.path.exists(VpdMapFilePath):\r
VpdFile.Read(VpdMapFilePath)\r
- \r
+\r
# Fixup "*" offset\r
for Pcd in self._DynamicPcdList:\r
# just pick the a value to determine whether is unicode string type\r
i += 1\r
else:\r
EdkLogger.error("build", FILE_READ_FAILURE, "Can not find VPD map file %s to fix up VPD offset." % VpdMapFilePath)\r
- \r
+\r
# Delete the DynamicPcdList At the last time enter into this function \r
- del self._DynamicPcdList[:] \r
+ del self._DynamicPcdList[:]\r
self._DynamicPcdList.extend(UnicodePcdArray)\r
self._DynamicPcdList.extend(HiiPcdArray)\r
self._DynamicPcdList.extend(OtherPcdArray)\r
def _GetFdfFile(self):\r
if self._FdfFile == None:\r
if self.Workspace.FdfFile != "":\r
- self._FdfFile= path.join(self.WorkspaceDir, self.Workspace.FdfFile)\r
+ self._FdfFile= mws.join(self.WorkspaceDir, self.Workspace.FdfFile)\r
else:\r
self._FdfFile = ''\r
return self._FdfFile\r
else:\r
if self._BuildRule._FileVersion < AutoGenReqBuildRuleVerNum :\r
# If Build Rule's version is less than the version number required by the tools, halting the build.\r
- EdkLogger.error("build", AUTOGEN_ERROR, \r
+ EdkLogger.error("build", AUTOGEN_ERROR,\r
ExtraData="The version number [%s] of build_rule.txt is less than the version number required by the AutoGen.(the minimum required version number is [%s])"\\r
% (self._BuildRule._FileVersion, AutoGenReqBuildRuleVerNum))\r
- \r
+\r
return self._BuildRule\r
\r
## Summarize the packages used by modules in this platform\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
+\r
for Pcd in self.DynamicPcdList:\r
if Pcd.Phase == "PEI":\r
if Pcd.Type in ["DynamicEx", "DynamicExDefault", "DynamicExVpd", "DynamicExHii"]:\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
+\r
for Pcd in self.DynamicPcdList:\r
if Pcd.Phase == "DXE":\r
if Pcd.Type in ["Dynamic", "DynamicDefault", "DynamicVpd", "DynamicHii"]:\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
+\r
for Pcd in self.DynamicPcdList:\r
if Pcd.Phase == "DXE":\r
if Pcd.Type in ["DynamicEx", "DynamicExDefault", "DynamicExVpd", "DynamicExHii"]:\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
+\r
for Pcd in self.NonDynamicPcdList:\r
self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber\r
TokenNumber += 1\r
elif (ToPcd.Type not in [None, '']) and (FromPcd.Type not in [None, ''])\\r
and (ToPcd.Type != FromPcd.Type) and (ToPcd.Type in FromPcd.Type):\r
if ToPcd.Type.strip() == "DynamicEx":\r
- ToPcd.Type = FromPcd.Type \r
+ ToPcd.Type = FromPcd.Type\r
elif ToPcd.Type not in [None, ''] and FromPcd.Type not in [None, ''] \\r
and ToPcd.Type != FromPcd.Type:\r
EdkLogger.error("build", OPTION_CONFLICT, "Mismatched PCD type",\r
#\r
def ApplyPcdSetting(self, Module, Pcds):\r
# for each PCD in module\r
- for Name,Guid in Pcds:\r
- PcdInModule = Pcds[Name,Guid]\r
+ for Name, Guid in Pcds:\r
+ PcdInModule = Pcds[Name, Guid]\r
# find out the PCD setting in platform\r
- if (Name,Guid) in self.Platform.Pcds:\r
- PcdInPlatform = self.Platform.Pcds[Name,Guid]\r
+ if (Name, Guid) in self.Platform.Pcds:\r
+ PcdInPlatform = self.Platform.Pcds[Name, Guid]\r
else:\r
PcdInPlatform = None\r
# then override the settings if any\r
# @retval Value Priority value based on the priority list.\r
#\r
def CalculatePriorityValue(self, Key):\r
- Target, ToolChain, Arch, CommandType, Attr = Key.split('_') \r
- PriorityValue = 0x11111 \r
+ Target, ToolChain, Arch, CommandType, Attr = Key.split('_')\r
+ PriorityValue = 0x11111\r
if Target == "*":\r
PriorityValue &= 0x01111\r
if ToolChain == "*":\r
PriorityValue &= 0x11101\r
if Attr == "*":\r
PriorityValue &= 0x11110\r
- \r
- return self.PrioList["0x%0.5x"%PriorityValue]\r
- \r
+\r
+ return self.PrioList["0x%0.5x" % PriorityValue]\r
+\r
\r
## Expand * in build option key\r
#\r
BuildOptions = {}\r
FamilyMatch = False\r
FamilyIsNull = True\r
- \r
+\r
OverrideList = {}\r
#\r
# Construct a list contain the build options which need override.\r
# Key[0] -- tool family\r
# Key[1] -- TARGET_TOOLCHAIN_ARCH_COMMANDTYPE_ATTRIBUTE\r
#\r
- if Key[0] == self.BuildRuleFamily :\r
+ if (Key[0] == self.BuildRuleFamily and\r
+ (ModuleStyle == 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]) != None: \r
+ if OverrideList.get(Key[1]) != None:\r
OverrideList.pop(Key[1])\r
OverrideList[Key[1]] = Options[Key]\r
\r
# Use the highest priority value. \r
#\r
if (len(OverrideList) >= 2):\r
- KeyList = OverrideList.keys()\r
+ KeyList = OverrideList.keys()\r
for Index in range(len(KeyList)):\r
- NowKey = KeyList[Index]\r
+ NowKey = KeyList[Index]\r
Target1, ToolChain1, Arch1, CommandType1, Attr1 = NowKey.split("_")\r
for Index1 in range(len(KeyList) - Index - 1):\r
NextKey = KeyList[Index1 + Index + 1]\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)) != None: \r
+ if Options.get((self.BuildRuleFamily, NextKey)) != None:\r
Options.pop((self.BuildRuleFamily, NextKey))\r
else:\r
- if Options.get((self.BuildRuleFamily, NowKey)) != None: \r
+ if Options.get((self.BuildRuleFamily, NowKey)) != None:\r
Options.pop((self.BuildRuleFamily, NowKey))\r
\r
- \r
for Key in Options:\r
if ModuleStyle != None and len (Key) > 2:\r
# Check Module style is EDK or EDKII.\r
if Arch == "*" or Arch == self.Arch:\r
if Tool not in BuildOptions:\r
BuildOptions[Tool] = {}\r
- if Attr != "FLAGS" or Attr not in BuildOptions[Tool]:\r
+ if Attr != "FLAGS" or Attr not in BuildOptions[Tool] or Options[Key].startswith('='):\r
BuildOptions[Tool][Attr] = Options[Key]\r
else:\r
# append options for the same tool\r
# Build Option Family has been checked, which need't to be checked again for family.\r
if FamilyMatch or FamilyIsNull:\r
return BuildOptions\r
- \r
+\r
for Key in Options:\r
if ModuleStyle != None and len (Key) > 2:\r
# Check Module style is EDK or EDKII.\r
Family = Key[0]\r
Target, Tag, Arch, Tool, Attr = Key[1].split("_")\r
# if tool chain family doesn't match, skip it\r
- if Tool not in self.ToolDefinition or Family =="":\r
+ if Tool not in self.ToolDefinition or Family == "":\r
continue\r
# option has been added before\r
if Family != self.ToolDefinition[Tool][TAB_TOD_DEFINES_FAMILY]:\r
if Arch == "*" or Arch == self.Arch:\r
if Tool not in BuildOptions:\r
BuildOptions[Tool] = {}\r
- if Attr != "FLAGS" or Attr not in BuildOptions[Tool]:\r
+ if Attr != "FLAGS" or Attr not in BuildOptions[Tool] or Options[Key].startswith('='):\r
BuildOptions[Tool][Attr] = Options[Key]\r
else:\r
# append options for the same tool\r
# Get the different options for the different style module\r
if Module.AutoGenVersion < 0x00010005:\r
PlatformOptions = self.EdkBuildOption\r
+ ModuleTypeOptions = self.Platform.GetBuildOptionsByModuleType(EDK_NAME, Module.ModuleType)\r
else:\r
PlatformOptions = self.EdkIIBuildOption\r
+ ModuleTypeOptions = self.Platform.GetBuildOptionsByModuleType(EDKII_NAME, Module.ModuleType)\r
+ ModuleTypeOptions = self._ExpandBuildOption(ModuleTypeOptions)\r
ModuleOptions = self._ExpandBuildOption(Module.BuildOptions)\r
if Module in self.Platform.Modules:\r
PlatformModule = self.Platform.Modules[str(Module)]\r
PlatformModuleOptions = {}\r
\r
BuildRuleOrder = None\r
- for Options in [self.ToolDefinition, ModuleOptions, PlatformOptions, PlatformModuleOptions]:\r
+ for Options in [self.ToolDefinition, ModuleOptions, PlatformOptions, ModuleTypeOptions, PlatformModuleOptions]:\r
for Tool in Options:\r
for Attr in Options[Tool]:\r
if Attr == TAB_TOD_DEFINES_BUILDRULEORDER:\r
BuildRuleOrder = Options[Tool][Attr]\r
\r
- AllTools = set(ModuleOptions.keys() + PlatformOptions.keys() + PlatformModuleOptions.keys() + self.ToolDefinition.keys())\r
+ AllTools = set(ModuleOptions.keys() + PlatformOptions.keys() +\r
+ PlatformModuleOptions.keys() + ModuleTypeOptions.keys() +\r
+ self.ToolDefinition.keys())\r
BuildOptions = {}\r
for Tool in AllTools:\r
if Tool not in BuildOptions:\r
BuildOptions[Tool] = {}\r
\r
- for Options in [self.ToolDefinition, ModuleOptions, PlatformOptions, PlatformModuleOptions]:\r
+ for Options in [self.ToolDefinition, ModuleOptions, PlatformOptions, ModuleTypeOptions, PlatformModuleOptions]:\r
if Tool not in Options:\r
continue\r
for Attr in Options[Tool]:\r
BuildOptions[Tool][Attr] = ""\r
# check if override is indicated\r
if Value.startswith('='):\r
- BuildOptions[Tool][Attr] = Value[1:]\r
+ ToolPath = Value[1:]\r
+ ToolPath = mws.handleWsMacro(ToolPath)\r
+ BuildOptions[Tool][Attr] = ToolPath\r
else:\r
+ Value = mws.handleWsMacro(Value)\r
BuildOptions[Tool][Attr] += " " + Value\r
if Module.AutoGenVersion < 0x00010005 and self.Workspace.UniFlag != None:\r
#\r
return False\r
\r
self.SourceDir = self.MetaFile.SubDir\r
- if self.SourceDir.upper().find(self.WorkspaceDir.upper()) == 0:\r
- self.SourceDir = self.SourceDir[len(self.WorkspaceDir) + 1:]\r
+ self.SourceDir = mws.relpath(self.SourceDir, self.WorkspaceDir)\r
\r
self.SourceOverrideDir = None\r
# use overrided path defined in DSC file\r
if Module.MetaFile == self.MetaFile:\r
continue\r
if Module.Name == self.Name:\r
- EdkLogger.warn('build', 'Modules have same BaseName:\n %s\n %s' % (Module.MetaFile, self.MetaFile))\r
if uuid.UUID(Module.Guid) == uuid.UUID(self.Guid):\r
EdkLogger.error("build", FILE_DUPLICATED, 'Modules have same BaseName and FILE_GUID:\n'\r
' %s\n %s' % (Module.MetaFile, self.MetaFile))\r
# is the former use /I , the Latter used -I to specify include directories\r
#\r
if self.PlatformInfo.ToolChainFamily in ('MSFT'):\r
- gBuildOptIncludePattern = re.compile(r"(?:.*?)/I[ \t]*([^ ]*)", re.MULTILINE|re.DOTALL)\r
+ gBuildOptIncludePattern = re.compile(r"(?:.*?)/I[ \t]*([^ ]*)", re.MULTILINE | re.DOTALL)\r
elif self.PlatformInfo.ToolChainFamily in ('INTEL', 'GCC', 'RVCT'):\r
- gBuildOptIncludePattern = re.compile(r"(?:.*?)-I[ \t]*([^ ]*)", re.MULTILINE|re.DOTALL)\r
+ gBuildOptIncludePattern = re.compile(r"(?:.*?)-I[ \t]*([^ ]*)", re.MULTILINE | re.DOTALL)\r
else:\r
#\r
# New ToolChainFamily, don't known whether there is option to specify include directories\r
if self.AutoGenVersion >= 0x00010005 and len(IncPathList) > 0:\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
- EdkLogger.error("build", \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
+ EdkLogger.error("build",\r
PARAMETER_INVALID,\r
- ExtraData = ErrMsg, \r
- File = str(self.MetaFile))\r
+ ExtraData=ErrMsg,\r
+ File=str(self.MetaFile))\r
\r
\r
BuildOptionIncPathList += IncPathList\r
if File.IsBinary and File == Source and self._BinaryFileList != None and File in self._BinaryFileList:\r
# Skip all files that are not binary libraries\r
if not self.IsLibrary:\r
- continue \r
+ continue\r
RuleObject = self.BuildRules[TAB_DEFAULT_BINARY_FILE]\r
elif FileType in self.BuildRules:\r
RuleObject = self.BuildRules[FileType]\r
self._IncludePathList.append(self.DebugDir)\r
\r
for Package in self.Module.Packages:\r
- PackageDir = path.join(self.WorkspaceDir, Package.MetaFile.Dir)\r
+ PackageDir = mws.join(self.WorkspaceDir, Package.MetaFile.Dir)\r
if PackageDir not in self._IncludePathList:\r
self._IncludePathList.append(PackageDir)\r
for Inc in Package.Includes:\r
\r
return HiiExPcds\r
\r
+ def _GenOffsetBin(self):\r
+ VfrUniBaseName = {}\r
+ for SourceFile in self.Module.Sources:\r
+ if SourceFile.Type.upper() == ".VFR" :\r
+ #\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
+ #\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
+ return None\r
+ MapFileName = os.path.join(self.OutputDir, self.Name + ".map")\r
+ EfiFileName = os.path.join(self.OutputDir, self.Name + ".efi")\r
+ VfrUniOffsetList = GetVariableOffset(MapFileName, EfiFileName, VfrUniBaseName.values())\r
+ if not VfrUniOffsetList:\r
+ return None\r
+\r
+ OutputName = '%sOffset.bin' % self.Name\r
+ UniVfrOffsetFileName = os.path.join( self.OutputDir, OutputName)\r
+\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
+\r
+ # Use a instance of StringIO to cache data\r
+ fStringIO = StringIO('') \r
+\r
+ for Item in VfrUniOffsetList:\r
+ if (Item[0].find("Strings") != -1):\r
+ #\r
+ # UNI offset in image.\r
+ # GUID + Offset\r
+ # { 0x8913c5e0, 0x33f6, 0x4d86, { 0x9b, 0xf1, 0x43, 0xef, 0x89, 0xfc, 0x6, 0x66 } }\r
+ #\r
+ UniGuid = [0xe0, 0xc5, 0x13, 0x89, 0xf6, 0x33, 0x86, 0x4d, 0x9b, 0xf1, 0x43, 0xef, 0x89, 0xfc, 0x6, 0x66]\r
+ UniGuid = [chr(ItemGuid) for ItemGuid in UniGuid]\r
+ fStringIO.write(''.join(UniGuid)) \r
+ UniValue = pack ('Q', int (Item[1], 16))\r
+ fStringIO.write (UniValue)\r
+ else:\r
+ #\r
+ # VFR binary offset in image.\r
+ # GUID + Offset\r
+ # { 0xd0bc7cb4, 0x6a47, 0x495f, { 0xaa, 0x11, 0x71, 0x7, 0x46, 0xda, 0x6, 0xa2 } };\r
+ #\r
+ VfrGuid = [0xb4, 0x7c, 0xbc, 0xd0, 0x47, 0x6a, 0x5f, 0x49, 0xaa, 0x11, 0x71, 0x7, 0x46, 0xda, 0x6, 0xa2]\r
+ VfrGuid = [chr(ItemGuid) for ItemGuid in VfrGuid]\r
+ fStringIO.write(''.join(VfrGuid)) \r
+ type (Item[1]) \r
+ VfrValue = pack ('Q', int (Item[1], 16))\r
+ fStringIO.write (VfrValue)\r
+ #\r
+ # write data into file.\r
+ #\r
+ try : \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
+\r
+ fStringIO.close ()\r
+ fInputfile.close ()\r
+ return OutputName\r
+\r
## Create AsBuilt INF file the module\r
#\r
def CreateAsBuiltInf(self):\r
# Also find all packages that the DynamicEx PCDs depend on\r
Pcds = []\r
PatchablePcds = {}\r
- Packages = [] \r
+ Packages = []\r
PcdCheckList = []\r
PcdTokenSpaceList = []\r
for Pcd in self.ModulePcdList + self.LibraryPcdList:\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' : ['%s' % (Package.MetaFile.File.replace('\\', '/')) for Package in Packages],\r
'binary_item' : [],\r
'patchablepcd_item' : [],\r
'pcd_item' : [],\r
if 'PI_SPECIFICATION_VERSION' in self.Specification:\r
AsBuiltInfDict['module_pi_specification_version'] += [self.Specification['PI_SPECIFICATION_VERSION']]\r
\r
- OutputDir = self.OutputDir.replace('\\','/').strip('/')\r
+ OutputDir = self.OutputDir.replace('\\', '/').strip('/')\r
if self.ModuleType in ['BASE', 'USER_DEFINED']:\r
for Item in self.CodaTargetList:\r
- File = Item.Target.Path.replace('\\','/').strip('/').replace(OutputDir,'').strip('/')\r
- if Item.Target.Ext.lower() == '.aml': \r
+ File = Item.Target.Path.replace('\\', '/').strip('/').replace(OutputDir, '').strip('/')\r
+ if Item.Target.Ext.lower() == '.aml':\r
AsBuiltInfDict['binary_item'] += ['ASL|' + File]\r
- elif Item.Target.Ext.lower() == '.acpi': \r
+ elif Item.Target.Ext.lower() == '.acpi':\r
AsBuiltInfDict['binary_item'] += ['ACPI|' + File]\r
else:\r
AsBuiltInfDict['binary_item'] += ['BIN|' + File]\r
else:\r
for Item in self.CodaTargetList:\r
- File = Item.Target.Path.replace('\\','/').strip('/').replace(OutputDir,'').strip('/')\r
- if Item.Target.Ext.lower() == '.efi': \r
+ File = Item.Target.Path.replace('\\', '/').strip('/').replace(OutputDir, '').strip('/')\r
+ if Item.Target.Ext.lower() == '.efi':\r
AsBuiltInfDict['binary_item'] += ['PE32|' + self.Name + '.efi']\r
else:\r
AsBuiltInfDict['binary_item'] += ['BIN|' + File]\r
if self.DepexGenerated:\r
if self.ModuleType in ['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 ['DXE_DRIVER', 'DXE_RUNTIME_DRIVER', 'DXE_SAL_DRIVER', 'UEFI_DRIVER']:\r
AsBuiltInfDict['binary_item'] += ['DXE_DEPEX|' + self.Name + '.depex']\r
if self.ModuleType in ['DXE_SMM_DRIVER']:\r
AsBuiltInfDict['binary_item'] += ['SMM_DEPEX|' + self.Name + '.depex']\r
\r
+ Bin = self._GenOffsetBin()\r
+ if Bin:\r
+ AsBuiltInfDict['binary_item'] += ['BIN|%s' % Bin]\r
+\r
for Root, Dirs, Files in os.walk(OutputDir):\r
for File in Files:\r
if File.lower().endswith('.pdb'):\r