\r
## Import Modules\r
#\r
+from __future__ import print_function\r
+from __future__ import absolute_import\r
import Common.LongFilePathOs as os\r
import re\r
import os.path as path\r
# if it exists, just return it directly\r
return cls.__ObjectCache[Key]\r
# it didnt exist. create it, cache it, then return it\r
- RetVal = cls.__ObjectCache[Key] = super().__new__(cls)\r
+ RetVal = cls.__ObjectCache[Key] = super(AutoGen, cls).__new__(cls)\r
return RetVal\r
\r
def __init__ (self, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs):\r
- super().__init__()\r
+ super(AutoGen, self).__init__(self, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs)\r
\r
## hash() operator\r
#\r
# call super().__init__ then call the worker function with different parameter count\r
def __init__(self, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs):\r
if not hasattr(self, "_Init"):\r
- super().__init__(Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs)\r
+ super(WorkspaceAutoGen, self).__init__(Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs)\r
self._InitWorker(Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs)\r
self._Init = True\r
\r
SkippedArchList = set(self.ArchList).symmetric_difference(set(self.Platform.SupArchList))\r
EdkLogger.verbose("\nArch [%s] is ignored because the platform supports [%s] only!"\r
% (" ".join(SkippedArchList), " ".join(self.Platform.SupArchList)))\r
- self.ArchList = tuple(sorted(ArchList))\r
+ self.ArchList = tuple(ArchList)\r
\r
# Validate build target\r
if self.BuildTarget not in self.Platform.BuildTargets:\r
for BuildData in PGen.BuildDatabase._CACHE_.values():\r
if BuildData.Arch != Arch:\r
continue\r
- for key in list(BuildData.Pcds.keys()):\r
+ for key in BuildData.Pcds:\r
for SinglePcd in GlobalData.MixedPcd:\r
if (BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName) == SinglePcd:\r
for item in GlobalData.MixedPcd[SinglePcd]:\r
#\r
content = 'gCommandLineDefines: '\r
content += str(GlobalData.gCommandLineDefines)\r
- content += "\n"\r
+ content += os.linesep\r
content += 'BuildOptionPcd: '\r
content += str(GlobalData.BuildOptionPcd)\r
- content += "\n"\r
+ content += os.linesep\r
content += 'Active Platform: '\r
content += str(self.Platform)\r
- content += "\n"\r
+ content += os.linesep\r
if self.FdfFile:\r
content += 'Flash Image Definition: '\r
content += str(self.FdfFile)\r
- content += "\n"\r
+ content += os.linesep\r
SaveFileOnChange(os.path.join(self.BuildDir, 'BuildOptions'), content, False)\r
\r
#\r
if Pa.PcdTokenNumber:\r
if Pa.DynamicPcdList:\r
for Pcd in Pa.DynamicPcdList:\r
- PcdTokenNumber += "\n"\r
+ PcdTokenNumber += os.linesep\r
PcdTokenNumber += str((Pcd.TokenCName, Pcd.TokenSpaceGuidCName))\r
PcdTokenNumber += ' : '\r
PcdTokenNumber += str(Pa.PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName])\r
for files in AllWorkSpaceMetaFiles:\r
if files.endswith('.dec'):\r
continue\r
- f = open(files, 'rb')\r
+ f = open(files, 'r')\r
Content = f.read()\r
f.close()\r
m.update(Content)\r
if not os.path.exists(self.BuildDir):\r
os.makedirs(self.BuildDir)\r
with open(os.path.join(self.BuildDir, 'AutoGen'), 'w+') as file:\r
- for f in sorted(AllWorkSpaceMetaFiles):\r
+ for f in AllWorkSpaceMetaFiles:\r
print(f, file=file)\r
return True\r
\r
HashFile = os.path.join(PkgDir, Pkg.PackageName + '.hash')\r
m = hashlib.md5()\r
# Get .dec file's hash value\r
- f = open(Pkg.MetaFile.Path, 'rb')\r
+ f = open(Pkg.MetaFile.Path, 'r')\r
Content = f.read()\r
f.close()\r
m.update(Content)\r
for Root, Dirs, Files in os.walk(str(inc)):\r
for File in sorted(Files):\r
File_Path = os.path.join(Root, File)\r
- f = open(File_Path, 'rb')\r
+ f = open(File_Path, 'r')\r
Content = f.read()\r
f.close()\r
m.update(Content)\r
def _CheckAllPcdsTokenValueConflict(self):\r
for Pa in self.AutoGenObjectList:\r
for Package in Pa.PackageList:\r
- PcdList = list(Package.Pcds.values())\r
+ PcdList = Package.Pcds.values()\r
PcdList.sort(key=lambda x: int(x.TokenValue, 0))\r
Count = 0\r
while (Count < len(PcdList) - 1) :\r
Count += SameTokenValuePcdListCount\r
Count += 1\r
\r
- PcdList = list(Package.Pcds.values())\r
+ PcdList = Package.Pcds.values()\r
PcdList.sort(key=lambda x: "%s.%s" % (x.TokenSpaceGuidCName, x.TokenCName))\r
Count = 0\r
while (Count < len(PcdList) - 1) :\r
# call super().__init__ then call the worker function with different parameter count\r
def __init__(self, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs):\r
if not hasattr(self, "_Init"):\r
- super().__init__(self, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs)\r
+ super(PlatformAutoGen, self).__init__(self, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs)\r
self._InitWorker(Workspace, MetaFile, Target, Toolchain, Arch)\r
self._Init = True\r
#\r
if os.path.exists(VpdMapFilePath):\r
OrgVpdFile.Read(VpdMapFilePath)\r
PcdItems = OrgVpdFile.GetOffset(PcdNvStoreDfBuffer[0])\r
- NvStoreOffset = list(PcdItems.values())[0].strip() if PcdItems else '0'\r
+ NvStoreOffset = PcdItems.values()[0].strip() if PcdItems else '0'\r
else:\r
EdkLogger.error("build", FILE_READ_FAILURE, "Can not find VPD map file %s to fix up VPD offset." % VpdMapFilePath)\r
\r
FdfModuleList.append(os.path.normpath(InfName))\r
for M in self._MaList:\r
# F is the Module for which M is the module autogen\r
- for PcdFromModule in list(M.ModulePcdList) + list(M.LibraryPcdList):\r
+ for PcdFromModule in M.ModulePcdList + M.LibraryPcdList:\r
# make sure that the "VOID*" kind of datum has MaxDatumSize set\r
if PcdFromModule.DatumType == TAB_VOID and not PcdFromModule.MaxDatumSize:\r
NoDatumTypePcdList.add("%s.%s [%s]" % (PcdFromModule.TokenSpaceGuidCName, PcdFromModule.TokenCName, M.MetaFile))\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 = list(Pcd.SkuInfoList.values())[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
if not FoundFlag :\r
# just pick the a value to determine whether is unicode string type\r
SkuValueMap = {}\r
- SkuObjList = list(DscPcdEntry.SkuInfoList.items())\r
+ SkuObjList = DscPcdEntry.SkuInfoList.items()\r
DefaultSku = DscPcdEntry.SkuInfoList.get(TAB_DEFAULT)\r
if DefaultSku:\r
defaultindex = SkuObjList.index((TAB_DEFAULT, DefaultSku))\r
DscPcdEntry.TokenSpaceGuidValue = eachDec.Guids[DecPcdEntry.TokenSpaceGuidCName]\r
# Only fix the value while no value provided in DSC file.\r
if not Sku.DefaultValue:\r
- DscPcdEntry.SkuInfoList[list(DscPcdEntry.SkuInfoList.keys())[0]].DefaultValue = DecPcdEntry.DefaultValue\r
+ DscPcdEntry.SkuInfoList[DscPcdEntry.SkuInfoList.keys()[0]].DefaultValue = DecPcdEntry.DefaultValue\r
\r
if DscPcdEntry not in self._DynamicPcdList:\r
self._DynamicPcdList.append(DscPcdEntry)\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 = list(Pcd.SkuInfoList.values())[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
self._DynamicPcdList.extend(list(UnicodePcdArray))\r
self._DynamicPcdList.extend(list(HiiPcdArray))\r
self._DynamicPcdList.extend(list(OtherPcdArray))\r
- #python3.6 set is not ordered at all\r
- self._DynamicPcdList = sorted(self._DynamicPcdList, key=lambda x:(x.TokenSpaceGuidCName, x.TokenCName))\r
- self._NonDynamicPcdList = sorted(self._NonDynamicPcdList, key=lambda x: (x.TokenSpaceGuidCName, x.TokenCName))\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 isinstance(SkuId, str) and eval(SkuId) == 0 or SkuId == 0:\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
Pcd.MaxDatumSize = str(len(Value.split(',')))\r
else:\r
Pcd.MaxDatumSize = str(len(Value) - 1)\r
- return list(Pcds.values())\r
+ return Pcds.values()\r
\r
## Resolve library names to library modules\r
#\r
# Use the highest priority value.\r
#\r
if (len(OverrideList) >= 2):\r
- KeyList = list(OverrideList.keys())\r
+ KeyList = OverrideList.keys()\r
for Index in range(len(KeyList)):\r
NowKey = KeyList[Index]\r
Target1, ToolChain1, Arch1, CommandType1, Attr1 = NowKey.split("_")\r
if Attr == TAB_TOD_DEFINES_BUILDRULEORDER:\r
BuildRuleOrder = Options[Tool][Attr]\r
\r
- AllTools = set(list(ModuleOptions.keys()) + list(PlatformOptions.keys()) +\r
- list(PlatformModuleOptions.keys()) + list(ModuleTypeOptions.keys()) +\r
- list(self.ToolDefinition.keys()))\r
+ AllTools = set(ModuleOptions.keys() + PlatformOptions.keys() +\r
+ PlatformModuleOptions.keys() + ModuleTypeOptions.keys() +\r
+ self.ToolDefinition.keys())\r
BuildOptions = defaultdict(lambda: defaultdict(str))\r
- for Tool in sorted(AllTools):\r
+ for Tool in AllTools:\r
for Options in [self.ToolDefinition, ModuleOptions, PlatformOptions, ModuleTypeOptions, PlatformModuleOptions]:\r
if Tool not in Options:\r
continue\r
# call super().__init__ then call the worker function with different parameter count\r
def __init__(self, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs):\r
if not hasattr(self, "_Init"):\r
- super().__init__(Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs)\r
+ super(ModuleAutoGen, self).__init__(Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs)\r
self._InitWorker(Workspace, MetaFile, Target, Toolchain, Arch, *args)\r
self._Init = True\r
\r
EdkLogger.verbose("Module [%s] for [%s] is not employed by active platform\n" \\r
% (MetaFile, Arch))\r
return None\r
- return super().__new__(cls, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs)\r
+ return super(ModuleAutoGen, cls).__new__(cls, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs)\r
\r
## Initialize ModuleAutoGen\r
#\r
@cached_property\r
def IntroTargetList(self):\r
self.Targets\r
- return sorted(self._IntroBuildTargetList, key=lambda x: str(x.Target))\r
+ return self._IntroBuildTargetList\r
\r
@cached_property\r
def CodaTargetList(self):\r
self.Targets\r
- return sorted(self._FinalBuildTargetList, key=lambda x: str(x.Target))\r
+ return self._FinalBuildTargetList\r
\r
@cached_property\r
def FileTypes(self):\r
AutoFile = PathClass(gAutoGenStringFileName % {"module_name":self.Name}, self.DebugDir)\r
RetVal[AutoFile] = str(StringH)\r
self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)\r
- if UniStringBinBuffer is not None and UniStringBinBuffer.getvalue() != b"":\r
+ if UniStringBinBuffer is not None and UniStringBinBuffer.getvalue() != "":\r
AutoFile = PathClass(gAutoGenStringFormFileName % {"module_name":self.Name}, self.OutputDir)\r
RetVal[AutoFile] = UniStringBinBuffer.getvalue()\r
AutoFile.IsBinary = True\r
AutoFile = PathClass(gAutoGenImageDefFileName % {"module_name":self.Name}, self.DebugDir)\r
RetVal[AutoFile] = str(StringIdf)\r
self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)\r
- if IdfGenBinBuffer is not None and IdfGenBinBuffer.getvalue() != b"":\r
+ if IdfGenBinBuffer is not None and IdfGenBinBuffer.getvalue() != "":\r
AutoFile = PathClass(gAutoGenIdfFileName % {"module_name":self.Name}, self.OutputDir)\r
RetVal[AutoFile] = IdfGenBinBuffer.getvalue()\r
AutoFile.IsBinary = True\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, list(VfrUniBaseName.values()))\r
+ VfrUniOffsetList = GetVariableOffset(MapFileName, EfiFileName, VfrUniBaseName.values())\r
if not VfrUniOffsetList:\r
return None\r
\r
EdkLogger.error("build", FILE_OPEN_FAILURE, "File open failed for %s" % UniVfrOffsetFileName, None)\r
\r
# Use a instance of BytesIO to cache data\r
- fStringIO = BytesIO()\r
+ fStringIO = BytesIO('')\r
\r
for Item in VfrUniOffsetList:\r
if (Item[0].find("Strings") != -1):\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
- fStringIO.write(bytes(UniGuid))\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
# { 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
- fStringIO.write(bytes(VfrGuid))\r
+ VfrGuid = [chr(ItemGuid) for ItemGuid in VfrGuid]\r
+ fStringIO.write(''.join(VfrGuid))\r
VfrValue = pack ('Q', int (Item[1], 16))\r
fStringIO.write (VfrValue)\r
#\r
Packages = []\r
PcdCheckList = []\r
PcdTokenSpaceList = []\r
- for Pcd in list(self.ModulePcdList) + list(self.LibraryPcdList):\r
+ for Pcd in self.ModulePcdList + self.LibraryPcdList:\r
if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:\r
PatchablePcds.append(Pcd)\r
PcdCheckList.append((Pcd.TokenCName, Pcd.TokenSpaceGuidCName, TAB_PCDS_PATCHABLE_IN_MODULE))\r
AsBuiltInfDict['binary_item'].append('PE32|' + self.Name + '.efi')\r
else:\r
AsBuiltInfDict['binary_item'].append('BIN|' + File)\r
- if not self.DepexGenerated:\r
- DepexFile = os.path.join(self.OutputDir, self.Name + '.depex')\r
- if os.path.exists(DepexFile):\r
- self.DepexGenerated = True\r
if self.DepexGenerated:\r
self.OutputFile.add(self.Name + '.depex')\r
if self.ModuleType in [SUP_MODULE_PEIM]:\r
Padding = '0x00, '\r
if Unicode:\r
Padding = Padding * 2\r
- ArraySize = ArraySize // 2\r
+ ArraySize = ArraySize / 2\r
if ArraySize < (len(PcdValue) + 1):\r
if Pcd.MaxSizeUserSet:\r
EdkLogger.error("build", AUTOGEN_ERROR,\r
if os.path.exists (self.TimeStampPath):\r
os.remove (self.TimeStampPath)\r
with open(self.TimeStampPath, 'w+') as file:\r
- for f in sorted(FileSet):\r
+ for f in FileSet:\r
print(f, file=file)\r
\r
# Ignore generating makefile when it is a binary module\r
GlobalData.gModuleHash[self.Arch] = {}\r
m = hashlib.md5()\r
# Add Platform level hash\r
- m.update(GlobalData.gPlatformHash.encode('utf-8'))\r
+ m.update(GlobalData.gPlatformHash)\r
# Add Package level hash\r
if 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].encode('utf-8'))\r
+ m.update(GlobalData.gPackageHash[self.Arch][Pkg.PackageName])\r
\r
# Add Library hash\r
if 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].encode('utf-8'))\r
+ m.update(GlobalData.gModuleHash[self.Arch][Lib.Name])\r
\r
# Add Module self\r
- f = open(str(self.MetaFile), 'rb')\r
+ f = open(str(self.MetaFile), 'r')\r
Content = f.read()\r
f.close()\r
m.update(Content)\r
# Add Module's source files\r
if self.SourceFileList:\r
for File in sorted(self.SourceFileList, key=lambda x: str(x)):\r
- f = open(str(File), 'rb')\r
+ f = open(str(File), 'r')\r
Content = f.read()\r
f.close()\r
m.update(Content)\r
projects / mirror_edk2.git / blobdiff