diff --git a/BaseTools/Source/Python/CommonDataClass/FdfClass.py b/BaseTools/Source/Python/CommonDataClass/FdfClass.py index 64b58c2078..3df8208245 100644 --- a/BaseTools/Source/Python/CommonDataClass/FdfClass.py +++ b/BaseTools/Source/Python/CommonDataClass/FdfClass.py @@ -37,50 +37,6 @@ class FDClassObject: self.RegionList = [] self.vtfRawDict = {} -## FV data in FDF -# -# -class FvClassObject: - ## The constructor - # - # @param self The object pointer - # - def __init__(self): - self.UiFvName = None - self.CreateFileName = None - # 3-tuple list (blockSize, numBlocks, pcd) - self.BlockSizeList = [] - # DefineVarDict[var] = value - self.DefineVarDict = {} - # SetVarDict[var] = value - self.SetVarDict = {} - self.FvAlignment = None - # FvAttributeDict[attribute] = TRUE/FALSE (1/0) - self.FvAttributeDict = {} - self.FvNameGuid = None - self.FvNameString = None - self.AprioriSectionList = [] - self.FfsList = [] - self.BsBaseAddress = None - self.RtBaseAddress = None - -## Region data in FDF -# -# -class RegionClassObject: - ## The constructor - # - # @param self The object pointer - # - def __init__(self): - self.Offset = None # The begin position of the Region - self.Size = None # The Size of the Region - self.PcdOffset = None - self.PcdSize = None - self.SetVarDict = {} - self.RegionType = None - self.RegionDataList = [] - ## FFS data in FDF # # @@ -112,7 +68,6 @@ class FileStatementClassObject (FfsClassObject) : self.FvName = None self.FdName = None self.DefineVarDict = {} - self.AprioriSection = None self.KeepReloc = None ## INF statement data in FDF @@ -134,19 +89,6 @@ class FfsInfStatementClassObject(FfsClassObject): self.KeepReloc = None self.UseArch = None -## APRIORI section data in FDF -# -# -class AprioriSectionClassObject: - ## The constructor - # - # @param self The object pointer - # - def __init__(self): - # DefineVarDict[var] = value - self.DefineVarDict = {} - self.FfsList = [] - ## section data in FDF # # @@ -363,21 +305,6 @@ class CapsuleClassObject : self.CapsuleDataList = [] self.FmpPayloadList = [] -## VTF data in FDF -# -# -class VtfClassObject : - ## The constructor - # - # @param self The object pointer - # - def __init__(self): - self.KeyArch = None - self.ArchList = None - self.UiName = None - self.ResetBin = None - self.ComponentStatementList = [] - ## VTF component data in FDF # # diff --git a/BaseTools/Source/Python/Eot/EotMain.py b/BaseTools/Source/Python/Eot/EotMain.py index 49a1494126..2ad93cc6b4 100644 --- a/BaseTools/Source/Python/Eot/EotMain.py +++ b/BaseTools/Source/Python/Eot/EotMain.py @@ -36,10 +36,9 @@ import struct import uuid import copy import codecs +from GenFds.AprioriSection import DXE_APRIORI_GUID, PEI_APRIORI_GUID gGuidStringFormat = "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X" -gPeiAprioriFileNameGuid = '1b45cc0a-156a-428a-af62-49864da0e6e6' -gAprioriGuid = 'fc510ee7-ffdc-11d4-bd41-0080c73c8881' gIndention = -4 class Image(array): @@ -402,10 +401,10 @@ class FirmwareVolume(Image): if Ffs.Type == 0x05: FfsDxeCoreGuid = FfsID continue - if Ffs.Guid.lower() == gPeiAprioriFileNameGuid: + if Ffs.Guid.lower() == PEI_APRIORI_GUID.lower(): FfsPeiPrioriGuid = FfsID continue - if Ffs.Guid.lower() == gAprioriGuid: + if Ffs.Guid.lower() == DXE_APRIORI_GUID.lower(): FfsDxePrioriGuid = FfsID continue @@ -1084,6 +1083,371 @@ class Ffs(Image): State = property(_GetState, _SetState) + _FfsGuid = "8C8CE578-8A3D-4F1C-9935-896185C32DD3" + + _GUID_ = struct.Struct("16x 1I2H8B") + _LENGTH_ = struct.Struct("16x 16x 1Q") + _SIG_ = struct.Struct("16x 16x 8x 1I") + _ATTR_ = struct.Struct("16x 16x 8x 4x 1I") + _HLEN_ = struct.Struct("16x 16x 8x 4x 4x 1H") + _CHECKSUM_ = struct.Struct("16x 16x 8x 4x 4x 2x 1H") + + def __init__(self, Name=''): + Image.__init__(self) + self.Name = Name + self.FfsDict = sdict() + self.OrderedFfsDict = sdict() + self.UnDispatchedFfsDict = sdict() + self.ProtocolList = sdict() + + def CheckArchProtocol(self): + for Item in EotGlobalData.gArchProtocolGuids: + if Item.lower() not in EotGlobalData.gProtocolList: + return False + return True + + def ParseDepex(self, Depex, Type): + List = None + if Type == 'Ppi': + List = EotGlobalData.gPpiList + if Type == 'Protocol': + List = EotGlobalData.gProtocolList + DepexStack = [] + DepexList = [] + DepexString = '' + FileDepex = None + CouldBeLoaded = True + for Index in range(0, len(Depex.Expression)): + Item = Depex.Expression[Index] + if Item == 0x00: + Index = Index + 1 + Guid = gGuidStringFormat % Depex.Expression[Index] + if Guid in self.OrderedFfsDict and Depex.Expression[Index + 1] == 0x08: + return (True, 'BEFORE %s' % Guid, [Guid, 'BEFORE']) + elif Item == 0x01: + Index = Index + 1 + Guid = gGuidStringFormat % Depex.Expression[Index] + if Guid in self.OrderedFfsDict and Depex.Expression[Index + 1] == 0x08: + return (True, 'AFTER %s' % Guid, [Guid, 'AFTER']) + elif Item == 0x02: + Index = Index + 1 + Guid = gGuidStringFormat % Depex.Expression[Index] + if Guid.lower() in List: + DepexStack.append(True) + DepexList.append(Guid) + else: + DepexStack.append(False) + DepexList.append(Guid) + continue + elif Item == 0x03 or Item == 0x04: + DepexStack.append(eval(str(DepexStack.pop()) + ' ' + Depex._OPCODE_STRING_[Item].lower() + ' ' + str(DepexStack.pop()))) + DepexList.append(str(DepexList.pop()) + ' ' + Depex._OPCODE_STRING_[Item].upper() + ' ' + str(DepexList.pop())) + elif Item == 0x05: + DepexStack.append(eval(Depex._OPCODE_STRING_[Item].lower() + ' ' + str(DepexStack.pop()))) + DepexList.append(Depex._OPCODE_STRING_[Item].lower() + ' ' + str(DepexList.pop())) + elif Item == 0x06: + DepexStack.append(True) + DepexList.append('TRUE') + DepexString = DepexString + 'TRUE' + ' ' + elif Item == 0x07: + DepexStack.append(False) + DepexList.append('False') + DepexString = DepexString + 'FALSE' + ' ' + elif Item == 0x08: + if Index != len(Depex.Expression) - 1: + CouldBeLoaded = False + else: + CouldBeLoaded = DepexStack.pop() + else: + CouldBeLoaded = False + if DepexList != []: + DepexString = DepexList[0].strip() + return (CouldBeLoaded, DepexString, FileDepex) + + def Dispatch(self, Db = None): + if Db is None: + return False + self.UnDispatchedFfsDict = copy.copy(self.FfsDict) + # Find PeiCore, DexCore, PeiPriori, DxePriori first + FfsSecCoreGuid = None + FfsPeiCoreGuid = None + FfsDxeCoreGuid = None + FfsPeiPrioriGuid = None + FfsDxePrioriGuid = None + for FfsID in self.UnDispatchedFfsDict: + Ffs = self.UnDispatchedFfsDict[FfsID] + if Ffs.Type == 0x03: + FfsSecCoreGuid = FfsID + continue + if Ffs.Type == 0x04: + FfsPeiCoreGuid = FfsID + continue + if Ffs.Type == 0x05: + FfsDxeCoreGuid = FfsID + continue + if Ffs.Guid.lower() == PEI_APRIORI_GUID.lower(): + FfsPeiPrioriGuid = FfsID + continue + if Ffs.Guid.lower() == DXE_APRIORI_GUID.lower(): + FfsDxePrioriGuid = FfsID + continue + + # Parse SEC_CORE first + if FfsSecCoreGuid is not None: + self.OrderedFfsDict[FfsSecCoreGuid] = self.UnDispatchedFfsDict.pop(FfsSecCoreGuid) + self.LoadPpi(Db, FfsSecCoreGuid) + + # Parse PEI first + if FfsPeiCoreGuid is not None: + self.OrderedFfsDict[FfsPeiCoreGuid] = self.UnDispatchedFfsDict.pop(FfsPeiCoreGuid) + self.LoadPpi(Db, FfsPeiCoreGuid) + if FfsPeiPrioriGuid is not None: + # Load PEIM described in priori file + FfsPeiPriori = self.UnDispatchedFfsDict.pop(FfsPeiPrioriGuid) + if len(FfsPeiPriori.Sections) == 1: + Section = FfsPeiPriori.Sections.popitem()[1] + if Section.Type == 0x19: + GuidStruct = struct.Struct('1I2H8B') + Start = 4 + while len(Section) > Start: + Guid = GuidStruct.unpack_from(Section[Start : Start + 16]) + GuidString = gGuidStringFormat % Guid + Start = Start + 16 + if GuidString in self.UnDispatchedFfsDict: + self.OrderedFfsDict[GuidString] = self.UnDispatchedFfsDict.pop(GuidString) + self.LoadPpi(Db, GuidString) + + self.DisPatchPei(Db) + + # Parse DXE then + if FfsDxeCoreGuid is not None: + self.OrderedFfsDict[FfsDxeCoreGuid] = self.UnDispatchedFfsDict.pop(FfsDxeCoreGuid) + self.LoadProtocol(Db, FfsDxeCoreGuid) + if FfsDxePrioriGuid is not None: + # Load PEIM described in priori file + FfsDxePriori = self.UnDispatchedFfsDict.pop(FfsDxePrioriGuid) + if len(FfsDxePriori.Sections) == 1: + Section = FfsDxePriori.Sections.popitem()[1] + if Section.Type == 0x19: + GuidStruct = struct.Struct('1I2H8B') + Start = 4 + while len(Section) > Start: + Guid = GuidStruct.unpack_from(Section[Start : Start + 16]) + GuidString = gGuidStringFormat % Guid + Start = Start + 16 + if GuidString in self.UnDispatchedFfsDict: + self.OrderedFfsDict[GuidString] = self.UnDispatchedFfsDict.pop(GuidString) + self.LoadProtocol(Db, GuidString) + + self.DisPatchDxe(Db) + + def LoadProtocol(self, Db, ModuleGuid): + SqlCommand = """select GuidValue from Report + where SourceFileFullPath in + (select Value1 from Inf where BelongsToFile = + (select BelongsToFile from Inf + where Value1 = 'FILE_GUID' and Value2 like '%s' and Model = %s) + and Model = %s) + and ItemType = 'Protocol' and ItemMode = 'Produced'""" \ + % (ModuleGuid, 5001, 3007) + RecordSet = Db.TblReport.Exec(SqlCommand) + for Record in RecordSet: + SqlCommand = """select Value2 from Inf where BelongsToFile = + (select DISTINCT BelongsToFile from Inf + where Value1 = + (select SourceFileFullPath from Report + where GuidValue like '%s' and ItemMode = 'Callback')) + and Value1 = 'FILE_GUID'""" % Record[0] + CallBackSet = Db.TblReport.Exec(SqlCommand) + if CallBackSet != []: + EotGlobalData.gProtocolList[Record[0].lower()] = ModuleGuid + else: + EotGlobalData.gProtocolList[Record[0].lower()] = ModuleGuid + + def LoadPpi(self, Db, ModuleGuid): + SqlCommand = """select GuidValue from Report + where SourceFileFullPath in + (select Value1 from Inf where BelongsToFile = + (select BelongsToFile from Inf + where Value1 = 'FILE_GUID' and Value2 like '%s' and Model = %s) + and Model = %s) + and ItemType = 'Ppi' and ItemMode = 'Produced'""" \ + % (ModuleGuid, 5001, 3007) + RecordSet = Db.TblReport.Exec(SqlCommand) + for Record in RecordSet: + EotGlobalData.gPpiList[Record[0].lower()] = ModuleGuid + + def DisPatchDxe(self, Db): + IsInstalled = False + ScheduleList = sdict() + for FfsID in self.UnDispatchedFfsDict: + CouldBeLoaded = False + DepexString = '' + FileDepex = None + Ffs = self.UnDispatchedFfsDict[FfsID] + if Ffs.Type == 0x07: + # Get Depex + IsFoundDepex = False + for Section in Ffs.Sections.values(): + # Find Depex + if Section.Type == 0x13: + IsFoundDepex = True + CouldBeLoaded, DepexString, FileDepex = self.ParseDepex(Section._SubImages[4], 'Protocol') + break + if Section.Type == 0x01: + CompressSections = Section._SubImages[4] + for CompressSection in CompressSections.Sections: + if CompressSection.Type == 0x13: + IsFoundDepex = True + CouldBeLoaded, DepexString, FileDepex = self.ParseDepex(CompressSection._SubImages[4], 'Protocol') + break + if CompressSection.Type == 0x02: + NewSections = CompressSection._SubImages[4] + for NewSection in NewSections.Sections: + if NewSection.Type == 0x13: + IsFoundDepex = True + CouldBeLoaded, DepexString, FileDepex = self.ParseDepex(NewSection._SubImages[4], 'Protocol') + break + + # Not find Depex + if not IsFoundDepex: + CouldBeLoaded = self.CheckArchProtocol() + DepexString = '' + FileDepex = None + + # Append New Ffs + if CouldBeLoaded: + IsInstalled = True + NewFfs = self.UnDispatchedFfsDict.pop(FfsID) + NewFfs.Depex = DepexString + if FileDepex is not None: + ScheduleList.insert(FileDepex[1], FfsID, NewFfs, FileDepex[0]) + else: + ScheduleList[FfsID] = NewFfs + else: + self.UnDispatchedFfsDict[FfsID].Depex = DepexString + + for FfsID in ScheduleList: + NewFfs = ScheduleList.pop(FfsID) + FfsName = 'UnKnown' + self.OrderedFfsDict[FfsID] = NewFfs + self.LoadProtocol(Db, FfsID) + + SqlCommand = """select Value2 from Inf + where BelongsToFile = (select BelongsToFile from Inf where Value1 = 'FILE_GUID' and lower(Value2) = lower('%s') and Model = %s) + and Model = %s and Value1='BASE_NAME'""" % (FfsID, 5001, 5001) + RecordSet = Db.TblReport.Exec(SqlCommand) + if RecordSet != []: + FfsName = RecordSet[0][0] + + if IsInstalled: + self.DisPatchDxe(Db) + + def DisPatchPei(self, Db): + IsInstalled = False + for FfsID in self.UnDispatchedFfsDict: + CouldBeLoaded = True + DepexString = '' + FileDepex = None + Ffs = self.UnDispatchedFfsDict[FfsID] + if Ffs.Type == 0x06 or Ffs.Type == 0x08: + # Get Depex + for Section in Ffs.Sections.values(): + if Section.Type == 0x1B: + CouldBeLoaded, DepexString, FileDepex = self.ParseDepex(Section._SubImages[4], 'Ppi') + break + if Section.Type == 0x01: + CompressSections = Section._SubImages[4] + for CompressSection in CompressSections.Sections: + if CompressSection.Type == 0x1B: + CouldBeLoaded, DepexString, FileDepex = self.ParseDepex(CompressSection._SubImages[4], 'Ppi') + break + if CompressSection.Type == 0x02: + NewSections = CompressSection._SubImages[4] + for NewSection in NewSections.Sections: + if NewSection.Type == 0x1B: + CouldBeLoaded, DepexString, FileDepex = self.ParseDepex(NewSection._SubImages[4], 'Ppi') + break + + # Append New Ffs + if CouldBeLoaded: + IsInstalled = True + NewFfs = self.UnDispatchedFfsDict.pop(FfsID) + NewFfs.Depex = DepexString + self.OrderedFfsDict[FfsID] = NewFfs + self.LoadPpi(Db, FfsID) + else: + self.UnDispatchedFfsDict[FfsID].Depex = DepexString + + if IsInstalled: + self.DisPatchPei(Db) + + + def __str__(self): + global gIndention + gIndention += 4 + FvInfo = '\n' + ' ' * gIndention + FvInfo += "[FV:%s] file_system=%s size=%x checksum=%s\n" % (self.Name, self.FileSystemGuid, self.Size, self.Checksum) + FfsInfo = "\n".join([str(self.FfsDict[FfsId]) for FfsId in self.FfsDict]) + gIndention -= 4 + return FvInfo + FfsInfo + + def _Unpack(self): + Size = self._LENGTH_.unpack_from(self._BUF_, self._OFF_)[0] + self.empty() + self.extend(self._BUF_[self._OFF_:self._OFF_+Size]) + + # traverse the FFS + EndOfFv = Size + FfsStartAddress = self.HeaderSize + LastFfsObj = None + while FfsStartAddress < EndOfFv: + FfsObj = Ffs() + FfsObj.frombuffer(self, FfsStartAddress) + FfsId = repr(FfsObj) + if ((self.Attributes & 0x00000800) != 0 and len(FfsObj) == 0xFFFFFF) \ + or ((self.Attributes & 0x00000800) == 0 and len(FfsObj) == 0): + if LastFfsObj is not None: + LastFfsObj.FreeSpace = EndOfFv - LastFfsObj._OFF_ - len(LastFfsObj) + else: + if FfsId in self.FfsDict: + EdkLogger.error("FV", 0, "Duplicate GUID in FFS", + ExtraData="\t%s @ %s\n\t%s @ %s" \ + % (FfsObj.Guid, FfsObj.Offset, + self.FfsDict[FfsId].Guid, self.FfsDict[FfsId].Offset)) + self.FfsDict[FfsId] = FfsObj + if LastFfsObj is not None: + LastFfsObj.FreeSpace = FfsStartAddress - LastFfsObj._OFF_ - len(LastFfsObj) + + FfsStartAddress += len(FfsObj) + # + # align to next 8-byte aligned address: A = (A + 8 - 1) & (~(8 - 1)) + # The next FFS must be at the latest next 8-byte aligned address + # + FfsStartAddress = (FfsStartAddress + 7) & (~7) + LastFfsObj = FfsObj + + def _GetAttributes(self): + return self.GetField(self._ATTR_, 0)[0] + + def _GetSize(self): + return self.GetField(self._LENGTH_, 0)[0] + + def _GetChecksum(self): + return self.GetField(self._CHECKSUM_, 0)[0] + + def _GetHeaderLength(self): + return self.GetField(self._HLEN_, 0)[0] + + def _GetFileSystemGuid(self): + return gGuidStringFormat % self.GetField(self._GUID_, 0) + + Attributes = property(_GetAttributes) + Size = property(_GetSize) + Checksum = property(_GetChecksum) + HeaderSize = property(_GetHeaderLength) + FileSystemGuid = property(_GetFileSystemGuid) + ## MultipleFv() class # # A class for Multiple FV diff --git a/BaseTools/Source/Python/GenFds/AprioriSection.py b/BaseTools/Source/Python/GenFds/AprioriSection.py index 7196f7f2c7..e7b856a115 100644 --- a/BaseTools/Source/Python/GenFds/AprioriSection.py +++ b/BaseTools/Source/Python/GenFds/AprioriSection.py @@ -16,28 +16,31 @@ # Import Modules # from __future__ import absolute_import -from struct import * +from struct import pack import Common.LongFilePathOs as os from io import BytesIO -from . import FfsFileStatement +from .FfsFileStatement import FileStatement from .GenFdsGlobalVariable import GenFdsGlobalVariable -from CommonDataClass.FdfClass import AprioriSectionClassObject -from Common.StringUtils import * +from Common.StringUtils import NormPath from Common.Misc import SaveFileOnChange, PathClass -from Common import EdkLogger -from Common.BuildToolError import * +from Common.EdkLogger import error as EdkLoggerError +from Common.BuildToolError import RESOURCE_NOT_AVAILABLE from Common.DataType import TAB_COMMON +DXE_APRIORI_GUID = "FC510EE7-FFDC-11D4-BD41-0080C73C8881" +PEI_APRIORI_GUID = "1B45CC0A-156A-428A-AF62-49864DA0E6E6" + ## process APRIORI file data and generate PEI/DXE APRIORI file # # -class AprioriSection (AprioriSectionClassObject): +class AprioriSection (object): ## The constructor # # @param self The object pointer # def __init__(self): - AprioriSectionClassObject.__init__(self) + self.DefineVarDict = {} + self.FfsList = [] self.AprioriType = "" ## GenFfs() method @@ -50,16 +53,16 @@ class AprioriSection (AprioriSectionClassObject): # @retval string Generated file name # def GenFfs (self, FvName, Dict = {}, IsMakefile = False): - DXE_GUID = "FC510EE7-FFDC-11D4-BD41-0080C73C8881" - PEI_GUID = "1B45CC0A-156A-428A-AF62-49864DA0E6E6" Buffer = BytesIO('') - AprioriFileGuid = DXE_GUID if self.AprioriType == "PEI": - AprioriFileGuid = PEI_GUID + AprioriFileGuid = PEI_APRIORI_GUID + else: + AprioriFileGuid = DXE_APRIORI_GUID + OutputAprFilePath = os.path.join (GenFdsGlobalVariable.WorkSpaceDir, \ GenFdsGlobalVariable.FfsDir,\ AprioriFileGuid + FvName) - if not os.path.exists(OutputAprFilePath) : + if not os.path.exists(OutputAprFilePath): os.makedirs(OutputAprFilePath) OutputAprFileName = os.path.join( OutputAprFilePath, \ @@ -69,33 +72,30 @@ class AprioriSection (AprioriSectionClassObject): Dict.update(self.DefineVarDict) InfFileName = None - for FfsObj in self.FfsList : + for FfsObj in self.FfsList: Guid = "" - if isinstance(FfsObj, FfsFileStatement.FileStatement): + if isinstance(FfsObj, FileStatement): Guid = FfsObj.NameGuid else: InfFileName = NormPath(FfsObj.InfFileName) Arch = FfsObj.GetCurrentArch() - if Arch is not None: + if Arch: Dict['$(ARCH)'] = Arch InfFileName = GenFdsGlobalVariable.MacroExtend(InfFileName, Dict, Arch) - if Arch is not None: + if Arch: Inf = GenFdsGlobalVariable.WorkSpace.BuildObject[PathClass(InfFileName, GenFdsGlobalVariable.WorkSpaceDir), Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag] Guid = Inf.Guid - else: Inf = GenFdsGlobalVariable.WorkSpace.BuildObject[PathClass(InfFileName, GenFdsGlobalVariable.WorkSpaceDir), TAB_COMMON, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag] Guid = Inf.Guid - self.BinFileList = Inf.Module.Binaries - if self.BinFileList == []: - EdkLogger.error("GenFds", RESOURCE_NOT_AVAILABLE, + if not Inf.Module.Binaries: + EdkLoggerError("GenFds", RESOURCE_NOT_AVAILABLE, "INF %s not found in build ARCH %s!" \ % (InfFileName, GenFdsGlobalVariable.ArchList)) - GuidPart = Guid.split('-') Buffer.write(pack('I', long(GuidPart[0], 16))) Buffer.write(pack('H', int(GuidPart[1], 16))) @@ -123,4 +123,3 @@ class AprioriSection (AprioriSectionClassObject): 'EFI_FV_FILETYPE_FREEFORM', AprioriFileGuid, MakefilePath=MakefilePath) return AprFfsFileName - diff --git a/BaseTools/Source/Python/GenFds/Capsule.py b/BaseTools/Source/Python/GenFds/Capsule.py index baa6e1dfa2..df29c40dbd 100644 --- a/BaseTools/Source/Python/GenFds/Capsule.py +++ b/BaseTools/Source/Python/GenFds/Capsule.py @@ -16,22 +16,18 @@ # Import Modules # from __future__ import absolute_import -from .GenFdsGlobalVariable import GenFdsGlobalVariable -from .GenFdsGlobalVariable import FindExtendTool +from .GenFdsGlobalVariable import GenFdsGlobalVariable, FindExtendTool from CommonDataClass.FdfClass import CapsuleClassObject import Common.LongFilePathOs as os -import subprocess from io import BytesIO -from Common.Misc import SaveFileOnChange -from Common.Misc import PackRegistryFormatGuid +from Common.Misc import SaveFileOnChange, PackRegistryFormatGuid import uuid from struct import pack from Common import EdkLogger -from Common.BuildToolError import * +from Common.BuildToolError import GENFDS_ERROR +from Common.DataType import TAB_LINE_BREAK - -T_CHAR_LF = '\n' -WIN_CERT_REVISION = 0x0200 +WIN_CERT_REVISION = 0x0200 WIN_CERT_TYPE_EFI_GUID = 0x0EF1 EFI_CERT_TYPE_PKCS7_GUID = uuid.UUID('{4aafd29d-68df-49ee-8aa9-347d375665a7}') EFI_CERT_TYPE_RSA2048_SHA256_GUID = uuid.UUID('{a7717414-c616-4977-9420-844712a735bf}') @@ -39,7 +35,7 @@ EFI_CERT_TYPE_RSA2048_SHA256_GUID = uuid.UUID('{a7717414-c616-4977-9420-844712a7 ## create inf file describes what goes into capsule and call GenFv to generate capsule # # -class Capsule (CapsuleClassObject) : +class Capsule (CapsuleClassObject): ## The constructor # # @param self The object pointer @@ -210,16 +206,16 @@ class Capsule (CapsuleClassObject) : return self.GenFmpCapsule() CapInfFile = self.GenCapInf() - CapInfFile.writelines("[files]" + T_CHAR_LF) + CapInfFile.writelines("[files]" + TAB_LINE_BREAK) CapFileList = [] - for CapsuleDataObj in self.CapsuleDataList : + for CapsuleDataObj in self.CapsuleDataList: CapsuleDataObj.CapsuleName = self.CapsuleName FileName = CapsuleDataObj.GenCapsuleSubItem() CapsuleDataObj.CapsuleName = None CapFileList.append(FileName) CapInfFile.writelines("EFI_FILE_NAME = " + \ FileName + \ - T_CHAR_LF) + TAB_LINE_BREAK) SaveFileOnChange(self.CapInfFileName, CapInfFile.getvalue(), False) CapInfFile.close() # @@ -249,13 +245,13 @@ class Capsule (CapsuleClassObject) : self.UiCapsuleName + "_Cap" + '.inf') CapInfFile = BytesIO() #open (self.CapInfFileName , 'w+') - CapInfFile.writelines("[options]" + T_CHAR_LF) + CapInfFile.writelines("[options]" + TAB_LINE_BREAK) for Item in self.TokensDict: CapInfFile.writelines("EFI_" + \ Item + \ ' = ' + \ self.TokensDict[Item] + \ - T_CHAR_LF) + TAB_LINE_BREAK) return CapInfFile diff --git a/BaseTools/Source/Python/GenFds/CapsuleData.py b/BaseTools/Source/Python/GenFds/CapsuleData.py index 0caba8983d..6071e9f4a5 100644 --- a/BaseTools/Source/Python/GenFds/CapsuleData.py +++ b/BaseTools/Source/Python/GenFds/CapsuleData.py @@ -16,7 +16,6 @@ # Import Modules # from __future__ import absolute_import -from . import Ffs from .GenFdsGlobalVariable import GenFdsGlobalVariable from io import BytesIO from struct import pack diff --git a/BaseTools/Source/Python/GenFds/CompressSection.py b/BaseTools/Source/Python/GenFds/CompressSection.py index aaaabf84dc..51f6791fab 100644 --- a/BaseTools/Source/Python/GenFds/CompressSection.py +++ b/BaseTools/Source/Python/GenFds/CompressSection.py @@ -16,7 +16,7 @@ # Import Modules # from __future__ import absolute_import -from .Ffs import Ffs +from .Ffs import SectionSuffix from . import Section import subprocess import Common.LongFilePathOs as os @@ -86,7 +86,7 @@ class CompressSection (CompressSectionClassObject) : ModuleName + \ SUP_MODULE_SEC + \ SecNum + \ - Ffs.SectionSuffix['COMPRESS'] + SectionSuffix['COMPRESS'] OutputFile = os.path.normpath(OutputFile) DummyFile = OutputFile + '.dummy' GenFdsGlobalVariable.GenerateSection(DummyFile, SectFiles, InputAlign=SectAlign, IsMakefile=IsMakefile) diff --git a/BaseTools/Source/Python/GenFds/DataSection.py b/BaseTools/Source/Python/GenFds/DataSection.py index a6387b07c5..28f9b931ca 100644 --- a/BaseTools/Source/Python/GenFds/DataSection.py +++ b/BaseTools/Source/Python/GenFds/DataSection.py @@ -19,7 +19,7 @@ from __future__ import absolute_import from . import Section from .GenFdsGlobalVariable import GenFdsGlobalVariable import subprocess -from .Ffs import Ffs +from .Ffs import SectionSuffix import Common.LongFilePathOs as os from CommonDataClass.FdfClass import DataSectionClassObject from Common.Misc import PeImageClass @@ -121,7 +121,7 @@ class DataSection (DataSectionClassObject): ) self.SectFileName = TeFile - OutputFile = os.path.join (OutputPath, ModuleName + SUP_MODULE_SEC + SecNum + Ffs.SectionSuffix.get(self.SecType)) + OutputFile = os.path.join (OutputPath, ModuleName + SUP_MODULE_SEC + SecNum + SectionSuffix.get(self.SecType)) OutputFile = os.path.normpath(OutputFile) GenFdsGlobalVariable.GenerateSection(OutputFile, [self.SectFileName], Section.Section.SectionType.get(self.SecType), IsMakefile = IsMakefile) FileList = [OutputFile] diff --git a/BaseTools/Source/Python/GenFds/DepexSection.py b/BaseTools/Source/Python/GenFds/DepexSection.py index b2d123bfc0..78efc18816 100644 --- a/BaseTools/Source/Python/GenFds/DepexSection.py +++ b/BaseTools/Source/Python/GenFds/DepexSection.py @@ -18,8 +18,6 @@ from __future__ import absolute_import from . import Section from .GenFdsGlobalVariable import GenFdsGlobalVariable -import subprocess -from .Ffs import Ffs import Common.LongFilePathOs as os from CommonDataClass.FdfClass import DepexSectionClassObject from AutoGen.GenDepex import DependencyExpression @@ -46,9 +44,8 @@ class DepexSection (DepexSectionClassObject): GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag) for Inf in GenFdsGlobalVariable.FdfParser.Profile.InfList: - ModuleFile = PathClass(Inf, GenFdsGlobalVariable.WorkSpaceDir) ModuleData = GenFdsGlobalVariable.WorkSpace.BuildObject[ - ModuleFile, + PathClass(Inf, GenFdsGlobalVariable.WorkSpaceDir), Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag diff --git a/BaseTools/Source/Python/GenFds/EfiSection.py b/BaseTools/Source/Python/GenFds/EfiSection.py index 623b77d274..f8573b5c7d 100644 --- a/BaseTools/Source/Python/GenFds/EfiSection.py +++ b/BaseTools/Source/Python/GenFds/EfiSection.py @@ -20,7 +20,7 @@ from struct import * from . import Section from .GenFdsGlobalVariable import GenFdsGlobalVariable import subprocess -from .Ffs import Ffs +from .Ffs import SectionSuffix import Common.LongFilePathOs as os from CommonDataClass.FdfClass import EfiSectionClassObject from Common import EdkLogger @@ -124,7 +124,7 @@ class EfiSection (EfiSectionClassObject): BuildNumTuple = tuple() Num = SecNum - OutputFile = os.path.join( OutputPath, ModuleName + SUP_MODULE_SEC + str(Num) + Ffs.SectionSuffix.get(SectionType)) + OutputFile = os.path.join( OutputPath, ModuleName + SUP_MODULE_SEC + str(Num) + SectionSuffix.get(SectionType)) GenFdsGlobalVariable.GenerateSection(OutputFile, [], 'EFI_SECTION_VERSION', #Ui=StringData, Ver=BuildNum, @@ -135,7 +135,7 @@ class EfiSection (EfiSectionClassObject): for File in FileList: Index = Index + 1 Num = '%s.%d' %(SecNum, Index) - OutputFile = os.path.join(OutputPath, ModuleName + SUP_MODULE_SEC + Num + Ffs.SectionSuffix.get(SectionType)) + OutputFile = os.path.join(OutputPath, ModuleName + SUP_MODULE_SEC + Num + SectionSuffix.get(SectionType)) f = open(File, 'r') VerString = f.read() f.close() @@ -164,7 +164,7 @@ class EfiSection (EfiSectionClassObject): else: EdkLogger.error("GenFds", GENFDS_ERROR, "File: %s miss Version Section value" %InfFileName) Num = SecNum - OutputFile = os.path.join( OutputPath, ModuleName + SUP_MODULE_SEC + str(Num) + Ffs.SectionSuffix.get(SectionType)) + OutputFile = os.path.join( OutputPath, ModuleName + SUP_MODULE_SEC + str(Num) + SectionSuffix.get(SectionType)) GenFdsGlobalVariable.GenerateSection(OutputFile, [], 'EFI_SECTION_VERSION', #Ui=VerString, Ver=BuildNum, @@ -185,7 +185,7 @@ class EfiSection (EfiSectionClassObject): Num = SecNum if IsMakefile and StringData == ModuleNameStr: StringData = "$(MODULE_NAME)" - OutputFile = os.path.join( OutputPath, ModuleName + SUP_MODULE_SEC + str(Num) + Ffs.SectionSuffix.get(SectionType)) + OutputFile = os.path.join( OutputPath, ModuleName + SUP_MODULE_SEC + str(Num) + SectionSuffix.get(SectionType)) GenFdsGlobalVariable.GenerateSection(OutputFile, [], 'EFI_SECTION_USER_INTERFACE', Ui=StringData, IsMakefile=IsMakefile) OutputFileList.append(OutputFile) @@ -194,7 +194,7 @@ class EfiSection (EfiSectionClassObject): for File in FileList: Index = Index + 1 Num = '%s.%d' %(SecNum, Index) - OutputFile = os.path.join(OutputPath, ModuleName + SUP_MODULE_SEC + Num + Ffs.SectionSuffix.get(SectionType)) + OutputFile = os.path.join(OutputPath, ModuleName + SUP_MODULE_SEC + Num + SectionSuffix.get(SectionType)) f = open(File, 'r') UiString = f.read() f.close() @@ -218,7 +218,7 @@ class EfiSection (EfiSectionClassObject): Num = SecNum if IsMakefile and StringData == ModuleNameStr: StringData = "$(MODULE_NAME)" - OutputFile = os.path.join( OutputPath, ModuleName + SUP_MODULE_SEC + str(Num) + Ffs.SectionSuffix.get(SectionType)) + OutputFile = os.path.join( OutputPath, ModuleName + SUP_MODULE_SEC + str(Num) + SectionSuffix.get(SectionType)) GenFdsGlobalVariable.GenerateSection(OutputFile, [], 'EFI_SECTION_USER_INTERFACE', Ui=StringData, IsMakefile=IsMakefile) OutputFileList.append(OutputFile) @@ -239,7 +239,7 @@ class EfiSection (EfiSectionClassObject): """ Copy Map file to FFS output path """ Index = Index + 1 Num = '%s.%d' %(SecNum, Index) - OutputFile = os.path.join( OutputPath, ModuleName + SUP_MODULE_SEC + Num + Ffs.SectionSuffix.get(SectionType)) + OutputFile = os.path.join( OutputPath, ModuleName + SUP_MODULE_SEC + Num + SectionSuffix.get(SectionType)) File = GenFdsGlobalVariable.MacroExtend(File, Dict) #Get PE Section alignment when align is set to AUTO diff --git a/BaseTools/Source/Python/GenFds/FdfParser.py b/BaseTools/Source/Python/GenFds/FdfParser.py index 63687e98bb..62bf9f1401 100644 --- a/BaseTools/Source/Python/GenFds/FdfParser.py +++ b/BaseTools/Source/Python/GenFds/FdfParser.py @@ -18,79 +18,66 @@ # from __future__ import print_function from __future__ import absolute_import -import re +from re import compile, DOTALL +from string import hexdigits +from uuid import UUID -from . import Fd -from . import Region -from . import Fv -from . import AprioriSection -from . import FfsInfStatement -from . import FfsFileStatement -from . import VerSection -from . import UiSection -from . import FvImageSection -from . import DataSection -from . import DepexSection -from . import CompressSection -from . import GuidSection -from . import Capsule -from . import CapsuleData -from . import Rule -from . import RuleComplexFile -from . import RuleSimpleFile -from . import EfiSection -from . import Vtf -from . import ComponentStatement -from . import OptionRom -from . import OptRomInfStatement -from . import OptRomFileStatement -import string - -from .GenFdsGlobalVariable import GenFdsGlobalVariable from Common.BuildToolError import * from Common import EdkLogger -from Common.Misc import PathClass -from Common.StringUtils import NormPath -import Common.GlobalData as GlobalData -from Common.Expression import * +from Common.Misc import PathClass, tdict +from Common.StringUtils import NormPath, ReplaceMacro from Common import GlobalData +from Common.Expression import * from Common.DataType import * -from Common.StringUtils import ReplaceMacro -import uuid -from Common.Misc import tdict from Common.MultipleWorkspace import MultipleWorkspace as mws import Common.LongFilePathOs as os from Common.LongFilePathSupport import OpenLongFilePath as open -from .Capsule import EFI_CERT_TYPE_PKCS7_GUID -from .Capsule import EFI_CERT_TYPE_RSA2048_SHA256_GUID from Common.RangeExpression import RangeExpression from collections import OrderedDict -##define T_CHAR_SPACE ' ' -##define T_CHAR_NULL '\0' -##define T_CHAR_CR '\r' -##define T_CHAR_TAB '\t' -##define T_CHAR_LF '\n' -##define T_CHAR_SLASH '/' -##define T_CHAR_BACKSLASH '\\' -##define T_CHAR_DOUBLE_QUOTE '\"' -##define T_CHAR_SINGLE_QUOTE '\'' -##define T_CHAR_STAR '*' -##define T_CHAR_HASH '#' +from .Fd import FD +from .Region import Region +from .Fv import FV +from .AprioriSection import AprioriSection +from .FfsInfStatement import FfsInfStatement +from .FfsFileStatement import FileStatement +from .VerSection import VerSection +from .UiSection import UiSection +from .FvImageSection import FvImageSection +from .DataSection import DataSection +from .DepexSection import DepexSection +from .CompressSection import CompressSection +from .GuidSection import GuidSection +from .Capsule import EFI_CERT_TYPE_PKCS7_GUID, EFI_CERT_TYPE_RSA2048_SHA256_GUID, Capsule +from .CapsuleData import CapsuleFfs, CapsulePayload, CapsuleFv, CapsuleFd, CapsuleAnyFile, CapsuleAfile +from .RuleComplexFile import RuleComplexFile +from .RuleSimpleFile import RuleSimpleFile +from .EfiSection import EfiSection +from .Vtf import Vtf +from .ComponentStatement import ComponentStatement +from .OptionRom import OPTIONROM +from .OptRomInfStatement import OptRomInfStatement, OverrideAttribs +from .OptRomFileStatement import OptRomFileStatement +from .GenFdsGlobalVariable import GenFdsGlobalVariable -(T_CHAR_SPACE, T_CHAR_NULL, T_CHAR_CR, T_CHAR_TAB, T_CHAR_LF, T_CHAR_SLASH, \ -T_CHAR_BACKSLASH, T_CHAR_DOUBLE_QUOTE, T_CHAR_SINGLE_QUOTE, T_CHAR_STAR, T_CHAR_HASH) = \ -(' ', '\0', '\r', '\t', '\n', '/', '\\', '\"', '\'', '*', '#') +T_CHAR_CR = '\r' +T_CHAR_TAB = '\t' +T_CHAR_DOUBLE_QUOTE = '\"' +T_CHAR_SINGLE_QUOTE = '\'' +T_CHAR_STAR = '*' -SEPERATOR_TUPLE = ('=', '|', ',', '{', '}') +SEPARATORS = {TAB_EQUAL_SPLIT, TAB_VALUE_SPLIT, TAB_COMMA_SPLIT, '{', '}'} +ALIGNMENTS = {"Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K", "64K", "128K", + "256K", "512K", "1M", "2M", "4M", "8M", "16M"} +ALIGNMENT_NOAUTO = ALIGNMENTS - {"Auto"} -RegionSizePattern = re.compile("\s*(?P(?:0x|0X)?[a-fA-F0-9]+)\s*\|\s*(?P(?:0x|0X)?[a-fA-F0-9]+)\s*") -RegionSizeGuidPattern = re.compile("\s*(?P\w+\.\w+[\.\w\[\]]*)\s*\|\s*(?P\w+\.\w+[\.\w\[\]]*)\s*") -RegionOffsetPcdPattern = re.compile("\s*(?P\w+\.\w+[\.\w\[\]]*)\s*$") -ShortcutPcdPattern = re.compile("\s*\w+\s*=\s*(?P(?:0x|0X)?[a-fA-F0-9]+)\s*\|\s*(?P\w+\.\w+)\s*") -BaseAddrValuePattern = re.compile('^0[xX][0-9a-fA-F]+') -FileExtensionPattern = re.compile(r'([a-zA-Z][a-zA-Z0-9]*)') -TokenFindPattern = re.compile(r'([a-zA-Z0-9\-]+|\$\(TARGET\)|\*)_([a-zA-Z0-9\-]+|\$\(TOOL_CHAIN_TAG\)|\*)_([a-zA-Z0-9\-]+|\$\(ARCH\)|\*)') +RegionSizePattern = compile("\s*(?P(?:0x|0X)?[a-fA-F0-9]+)\s*\|\s*(?P(?:0x|0X)?[a-fA-F0-9]+)\s*") +RegionSizeGuidPattern = compile("\s*(?P\w+\.\w+[\.\w\[\]]*)\s*\|\s*(?P\w+\.\w+[\.\w\[\]]*)\s*") +RegionOffsetPcdPattern = compile("\s*(?P\w+\.\w+[\.\w\[\]]*)\s*$") +ShortcutPcdPattern = compile("\s*\w+\s*=\s*(?P(?:0x|0X)?[a-fA-F0-9]+)\s*\|\s*(?P\w+\.\w+)\s*") +BaseAddrValuePattern = compile('^0[xX][0-9a-fA-F]+') +FileExtensionPattern = compile(r'([a-zA-Z][a-zA-Z0-9]*)') +TokenFindPattern = compile(r'([a-zA-Z0-9\-]+|\$\(TARGET\)|\*)_([a-zA-Z0-9\-]+|\$\(TOOL_CHAIN_TAG\)|\*)_([a-zA-Z0-9\-]+|\$\(ARCH\)|\*)') AllIncludeFileList = [] # Get the closest parent @@ -109,7 +96,6 @@ def IsValidInclude (File, Line): return True def GetRealFileLine (File, Line): - InsertedLines = 0 for Profile in AllIncludeFileList: if Profile.IsLineInFile(Line): @@ -121,7 +107,7 @@ def GetRealFileLine (File, Line): ## The exception class that used to report error messages when parsing FDF # -# Currently the "ToolName" is set to be "FDF Parser". +# Currently the "ToolName" is set to be "FdfParser". # class Warning (Exception): ## The constructor @@ -132,7 +118,6 @@ class Warning (Exception): # @param Line The Line number that error occurs # def __init__(self, Str, File = None, Line = None): - FileLineTuple = GetRealFileLine(File, Line) self.FileName = FileLineTuple[0] self.LineNumber = FileLineTuple[1] @@ -147,7 +132,7 @@ class Warning (Exception): # # May raise Exception when opening file. # -class IncludeFileProfile : +class IncludeFileProfile: ## The constructor # # @param self The object pointer @@ -157,16 +142,11 @@ class IncludeFileProfile : self.FileName = FileName self.FileLinesList = [] try: - fsock = open(FileName, "rb", 0) - try: + with open(FileName, "rb", 0) as fsock: self.FileLinesList = fsock.readlines() for index, line in enumerate(self.FileLinesList): - if not line.endswith('\n'): - self.FileLinesList[index] += '\n' - - finally: - fsock.close() - + if not line.endswith(TAB_LINE_BREAK): + self.FileLinesList[index] += TAB_LINE_BREAK except: EdkLogger.error("FdfParser", FILE_OPEN_FAILURE, ExtraData=FileName) @@ -209,7 +189,7 @@ class IncludeFileProfile : # # May raise Exception when opening file. # -class FileProfile : +class FileProfile: ## The constructor # # @param self The object pointer @@ -218,11 +198,8 @@ class FileProfile : def __init__(self, FileName): self.FileLinesList = [] try: - fsock = open(FileName, "rb", 0) - try: + with open(FileName, "rb", 0) as fsock: self.FileLinesList = fsock.readlines() - finally: - fsock.close() except: EdkLogger.error("FdfParser", FILE_OPEN_FAILURE, ExtraData=FileName) @@ -266,41 +243,37 @@ class FdfParser: self.CurrentOffsetWithinLine = 0 self.CurrentFdName = None self.CurrentFvName = None - self.__Token = "" - self.__SkippedChars = "" + self._Token = "" + self._SkippedChars = "" GlobalData.gFdfParser = self # Used to section info - self.__CurSection = [] + self._CurSection = [] # Key: [section name, UI name, arch] - # Value: {MACRO_NAME : MACRO_VALUE} - self.__MacroDict = tdict(True, 3) - self.__PcdDict = OrderedDict() + # Value: {MACRO_NAME: MACRO_VALUE} + self._MacroDict = tdict(True, 3) + self._PcdDict = OrderedDict() - self.__WipeOffArea = [] + self._WipeOffArea = [] if GenFdsGlobalVariable.WorkSpaceDir == '': GenFdsGlobalVariable.WorkSpaceDir = os.getenv("WORKSPACE") - ## __SkipWhiteSpace() method + ## _SkipWhiteSpace() method # - # Skip white spaces from current char, return number of chars skipped + # Skip white spaces from current char. # # @param self The object pointer - # @retval Count The number of chars skipped # - def __SkipWhiteSpace(self): - Count = 0 - while not self.__EndOfFile(): - Count += 1 - if self.__CurrentChar() in (T_CHAR_NULL, T_CHAR_CR, T_CHAR_LF, T_CHAR_SPACE, T_CHAR_TAB): - self.__SkippedChars += str(self.__CurrentChar()) - self.__GetOneChar() - + def _SkipWhiteSpace(self): + while not self._EndOfFile(): + if self._CurrentChar() in (TAB_PRINTCHAR_NUL, T_CHAR_CR, TAB_LINE_BREAK, TAB_SPACE_SPLIT, T_CHAR_TAB): + self._SkippedChars += str(self._CurrentChar()) + self._GetOneChar() else: - Count = Count - 1 - return Count + return + return - ## __EndOfFile() method + ## _EndOfFile() method # # Judge current buffer pos is at file end # @@ -308,17 +281,16 @@ class FdfParser: # @retval True Current File buffer position is at file end # @retval False Current File buffer position is NOT at file end # - def __EndOfFile(self): + def _EndOfFile(self): NumberOfLines = len(self.Profile.FileLinesList) SizeOfLastLine = len(self.Profile.FileLinesList[-1]) if self.CurrentLineNumber == NumberOfLines and self.CurrentOffsetWithinLine >= SizeOfLastLine - 1: return True - elif self.CurrentLineNumber > NumberOfLines: + if self.CurrentLineNumber > NumberOfLines: return True - else: - return False + return False - ## __EndOfLine() method + ## _EndOfLine() method # # Judge current buffer pos is at line end # @@ -326,14 +298,13 @@ class FdfParser: # @retval True Current File buffer position is at line end # @retval False Current File buffer position is NOT at line end # - def __EndOfLine(self): + def _EndOfLine(self): if self.CurrentLineNumber > len(self.Profile.FileLinesList): return True SizeOfCurrentLine = len(self.Profile.FileLinesList[self.CurrentLineNumber - 1]) if self.CurrentOffsetWithinLine >= SizeOfCurrentLine: return True - else: - return False + return False ## Rewind() method # @@ -347,7 +318,7 @@ class FdfParser: self.CurrentLineNumber = DestLine self.CurrentOffsetWithinLine = DestOffset - ## __UndoOneChar() method + ## _UndoOneChar() method # # Go back one char in the file buffer # @@ -355,80 +326,78 @@ class FdfParser: # @retval True Successfully go back one char # @retval False Not able to go back one char as file beginning reached # - def __UndoOneChar(self): - + def _UndoOneChar(self): if self.CurrentLineNumber == 1 and self.CurrentOffsetWithinLine == 0: return False elif self.CurrentOffsetWithinLine == 0: self.CurrentLineNumber -= 1 - self.CurrentOffsetWithinLine = len(self.__CurrentLine()) - 1 + self.CurrentOffsetWithinLine = len(self._CurrentLine()) - 1 else: self.CurrentOffsetWithinLine -= 1 return True - ## __GetOneChar() method + ## _GetOneChar() method # # Move forward one char in the file buffer # # @param self The object pointer # - def __GetOneChar(self): + def _GetOneChar(self): if self.CurrentOffsetWithinLine == len(self.Profile.FileLinesList[self.CurrentLineNumber - 1]) - 1: self.CurrentLineNumber += 1 self.CurrentOffsetWithinLine = 0 else: self.CurrentOffsetWithinLine += 1 - ## __CurrentChar() method + ## _CurrentChar() method # # Get the char pointed to by the file buffer pointer # # @param self The object pointer # @retval Char Current char # - def __CurrentChar(self): + def _CurrentChar(self): return self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine] - ## __NextChar() method + ## _NextChar() method # # Get the one char pass the char pointed to by the file buffer pointer # # @param self The object pointer # @retval Char Next char # - def __NextChar(self): + def _NextChar(self): if self.CurrentOffsetWithinLine == len(self.Profile.FileLinesList[self.CurrentLineNumber - 1]) - 1: return self.Profile.FileLinesList[self.CurrentLineNumber][0] - else: - return self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine + 1] + return self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine + 1] - ## __SetCurrentCharValue() method + ## _SetCurrentCharValue() method # # Modify the value of current char # # @param self The object pointer # @param Value The new value of current char # - def __SetCurrentCharValue(self, Value): + def _SetCurrentCharValue(self, Value): self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine] = Value - ## __CurrentLine() method + ## _CurrentLine() method # # Get the list that contains current line contents # # @param self The object pointer # @retval List current line contents # - def __CurrentLine(self): + def _CurrentLine(self): return self.Profile.FileLinesList[self.CurrentLineNumber - 1] - def __StringToList(self): + def _StringToList(self): self.Profile.FileLinesList = [list(s) for s in self.Profile.FileLinesList] if not self.Profile.FileLinesList: EdkLogger.error('FdfParser', FILE_READ_FAILURE, 'The file is empty!', File=self.FileName) self.Profile.FileLinesList[-1].append(' ') - def __ReplaceFragment(self, StartPos, EndPos, Value = ' '): + def _ReplaceFragment(self, StartPos, EndPos, Value = ' '): if StartPos[0] == EndPos[0]: Offset = StartPos[1] while Offset <= EndPos[1]: @@ -437,14 +406,14 @@ class FdfParser: return Offset = StartPos[1] - while self.Profile.FileLinesList[StartPos[0]][Offset] not in ('\r', '\n'): + while self.Profile.FileLinesList[StartPos[0]][Offset] not in (T_CHAR_CR, TAB_LINE_BREAK): self.Profile.FileLinesList[StartPos[0]][Offset] = Value Offset += 1 Line = StartPos[0] while Line < EndPos[0]: Offset = 0 - while self.Profile.FileLinesList[Line][Offset] not in ('\r', '\n'): + while self.Profile.FileLinesList[Line][Offset] not in (T_CHAR_CR, TAB_LINE_BREAK): self.Profile.FileLinesList[Line][Offset] = Value Offset += 1 Line += 1 @@ -454,45 +423,29 @@ class FdfParser: self.Profile.FileLinesList[EndPos[0]][Offset] = Value Offset += 1 - - def __GetMacroName(self): - if not self.__GetNextToken(): - raise Warning("expected Macro name", self.FileName, self.CurrentLineNumber) - MacroName = self.__Token - NotFlag = False - if MacroName.startswith('!'): - NotFlag = True - MacroName = MacroName[1:].strip() - - if not MacroName.startswith('$(') or not MacroName.endswith(')'): - raise Warning("Macro name expected(Please use '$(%(Token)s)' if '%(Token)s' is a macro.)" % {"Token" : MacroName}, - self.FileName, self.CurrentLineNumber) - MacroName = MacroName[2:-1] - return MacroName, NotFlag - - def __SetMacroValue(self, Macro, Value): - if not self.__CurSection: + def _SetMacroValue(self, Macro, Value): + if not self._CurSection: return MacroDict = {} - if not self.__MacroDict[self.__CurSection[0], self.__CurSection[1], self.__CurSection[2]]: - self.__MacroDict[self.__CurSection[0], self.__CurSection[1], self.__CurSection[2]] = MacroDict + if not self._MacroDict[self._CurSection[0], self._CurSection[1], self._CurSection[2]]: + self._MacroDict[self._CurSection[0], self._CurSection[1], self._CurSection[2]] = MacroDict else: - MacroDict = self.__MacroDict[self.__CurSection[0], self.__CurSection[1], self.__CurSection[2]] + MacroDict = self._MacroDict[self._CurSection[0], self._CurSection[1], self._CurSection[2]] MacroDict[Macro] = Value - def __GetMacroValue(self, Macro): + def _GetMacroValue(self, Macro): # Highest priority if Macro in GlobalData.gCommandLineDefines: return GlobalData.gCommandLineDefines[Macro] if Macro in GlobalData.gGlobalDefines: return GlobalData.gGlobalDefines[Macro] - if self.__CurSection: - MacroDict = self.__MacroDict[ - self.__CurSection[0], - self.__CurSection[1], - self.__CurSection[2] + if self._CurSection: + MacroDict = self._MacroDict[ + self._CurSection[0], + self._CurSection[1], + self._CurSection[2] ] if MacroDict and Macro in MacroDict: return MacroDict[Macro] @@ -502,7 +455,7 @@ class FdfParser: return GlobalData.gPlatformDefines[Macro] return None - def __SectionHeaderParser(self, Section): + def _SectionHeaderParser(self, Section): # [Defines] # [FD.UiName]: use dummy instead if UI name is optional # [FV.UiName] @@ -510,25 +463,25 @@ class FdfParser: # [Rule]: don't take rule section into account, macro is not allowed in this section # [VTF.arch.UiName, arch] # [OptionRom.DriverName] - self.__CurSection = [] - Section = Section.strip()[1:-1].upper().replace(' ', '').strip('.') - ItemList = Section.split('.') + self._CurSection = [] + Section = Section.strip()[1:-1].upper().replace(' ', '').strip(TAB_SPLIT) + ItemList = Section.split(TAB_SPLIT) Item = ItemList[0] if Item == '' or Item == 'RULE': return if Item == TAB_COMMON_DEFINES.upper(): - self.__CurSection = [TAB_COMMON, TAB_COMMON, TAB_COMMON] + self._CurSection = [TAB_COMMON, TAB_COMMON, TAB_COMMON] elif Item == 'VTF' and len(ItemList) == 3: UiName = ItemList[2] - Pos = UiName.find(',') + Pos = UiName.find(TAB_COMMA_SPLIT) if Pos != -1: UiName = UiName[:Pos] - self.__CurSection = ['VTF', UiName, ItemList[1]] + self._CurSection = ['VTF', UiName, ItemList[1]] elif len(ItemList) > 1: - self.__CurSection = [ItemList[0], ItemList[1], TAB_COMMON] + self._CurSection = [ItemList[0], ItemList[1], TAB_COMMON] elif len(ItemList) > 0: - self.__CurSection = [ItemList[0], 'DUMMY', TAB_COMMON] + self._CurSection = [ItemList[0], 'DUMMY', TAB_COMMON] ## PreprocessFile() method # @@ -540,7 +493,6 @@ class FdfParser: # @param self The object pointer # def PreprocessFile(self): - self.Rewind() InComment = False DoubleSlashComment = False @@ -548,12 +500,12 @@ class FdfParser: # HashComment in quoted string " " is ignored. InString = False - while not self.__EndOfFile(): + while not self._EndOfFile(): - if self.__CurrentChar() == T_CHAR_DOUBLE_QUOTE and not InComment: + if self._CurrentChar() == T_CHAR_DOUBLE_QUOTE and not InComment: InString = not InString # meet new line, then no longer in a comment for // and '#' - if self.__CurrentChar() == T_CHAR_LF: + if self._CurrentChar() == TAB_LINE_BREAK: self.CurrentLineNumber += 1 self.CurrentOffsetWithinLine = 0 if InComment and DoubleSlashComment: @@ -563,33 +515,33 @@ class FdfParser: InComment = False HashComment = False # check for */ comment end - elif InComment and not DoubleSlashComment and not HashComment and self.__CurrentChar() == T_CHAR_STAR and self.__NextChar() == T_CHAR_SLASH: - self.__SetCurrentCharValue(T_CHAR_SPACE) - self.__GetOneChar() - self.__SetCurrentCharValue(T_CHAR_SPACE) - self.__GetOneChar() + elif InComment and not DoubleSlashComment and not HashComment and self._CurrentChar() == T_CHAR_STAR and self._NextChar() == TAB_BACK_SLASH: + self._SetCurrentCharValue(TAB_SPACE_SPLIT) + self._GetOneChar() + self._SetCurrentCharValue(TAB_SPACE_SPLIT) + self._GetOneChar() InComment = False # set comments to spaces elif InComment: - self.__SetCurrentCharValue(T_CHAR_SPACE) - self.__GetOneChar() + self._SetCurrentCharValue(TAB_SPACE_SPLIT) + self._GetOneChar() # check for // comment - elif self.__CurrentChar() == T_CHAR_SLASH and self.__NextChar() == T_CHAR_SLASH and not self.__EndOfLine(): + elif self._CurrentChar() == TAB_BACK_SLASH and self._NextChar() == TAB_BACK_SLASH and not self._EndOfLine(): InComment = True DoubleSlashComment = True # check for '#' comment - elif self.__CurrentChar() == T_CHAR_HASH and not self.__EndOfLine() and not InString: + elif self._CurrentChar() == TAB_COMMENT_SPLIT and not self._EndOfLine() and not InString: InComment = True HashComment = True # check for /* comment start - elif self.__CurrentChar() == T_CHAR_SLASH and self.__NextChar() == T_CHAR_STAR: - self.__SetCurrentCharValue( T_CHAR_SPACE) - self.__GetOneChar() - self.__SetCurrentCharValue( T_CHAR_SPACE) - self.__GetOneChar() + elif self._CurrentChar() == TAB_BACK_SLASH and self._NextChar() == T_CHAR_STAR: + self._SetCurrentCharValue(TAB_SPACE_SPLIT) + self._GetOneChar() + self._SetCurrentCharValue(TAB_SPACE_SPLIT) + self._GetOneChar() InComment = True else: - self.__GetOneChar() + self._GetOneChar() # restore from ListOfList to ListOfString self.Profile.FileLinesList = ["".join(list) for list in self.Profile.FileLinesList] @@ -606,30 +558,30 @@ class FdfParser: # nested include support Processed = False MacroDict = {} - while self.__GetNextToken(): + while self._GetNextToken(): - if self.__Token == 'DEFINE': - if not self.__GetNextToken(): + if self._Token == TAB_DEFINE: + if not self._GetNextToken(): raise Warning("expected Macro name", self.FileName, self.CurrentLineNumber) - Macro = self.__Token - if not self.__IsToken( "="): + Macro = self._Token + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - Value = self.__GetExpression() + Value = self._GetExpression() MacroDict[Macro] = Value - elif self.__Token == '!include': + elif self._Token == TAB_INCLUDE: Processed = True IncludeLine = self.CurrentLineNumber - IncludeOffset = self.CurrentOffsetWithinLine - len('!include') - if not self.__GetNextToken(): + IncludeOffset = self.CurrentOffsetWithinLine - len(TAB_INCLUDE) + if not self._GetNextToken(): raise Warning("expected include file name", self.FileName, self.CurrentLineNumber) - IncFileName = self.__Token + IncFileName = self._Token PreIndex = 0 StartPos = IncFileName.find('$(', PreIndex) EndPos = IncFileName.find(')', StartPos+2) while StartPos != -1 and EndPos != -1: - Macro = IncFileName[StartPos+2 : EndPos] - MacroVal = self.__GetMacroValue(Macro) + Macro = IncFileName[StartPos+2: EndPos] + MacroVal = self._GetMacroValue(Macro) if not MacroVal: if Macro in MacroDict: MacroVal = MacroDict[Macro] @@ -686,9 +638,9 @@ class FdfParser: IncFileProfile.Level = ParentProfile.Level + 1 IncFileProfile.InsertStartLineNumber = InsertAtLine + 1 # deal with remaining portions after "!include filename", if exists. - if self.__GetNextToken(): + if self._GetNextToken(): if self.CurrentLineNumber == CurrentLine: - RemainingLine = self.__CurrentLine()[CurrentOffset:] + RemainingLine = self._CurrentLine()[CurrentOffset:] self.Profile.FileLinesList.insert(self.CurrentLineNumber, RemainingLine) IncFileProfile.InsertAdjust += 1 self.CurrentLineNumber += 1 @@ -704,7 +656,7 @@ class FdfParser: # comment out the processed include file statement TempList = list(self.Profile.FileLinesList[IncludeLine - 1]) - TempList.insert(IncludeOffset, '#') + TempList.insert(IncludeOffset, TAB_COMMENT_SPLIT) self.Profile.FileLinesList[IncludeLine - 1] = ''.join(TempList) if Processed: # Nested and back-to-back support self.Rewind(DestLine = IncFileProfile.InsertStartLineNumber - 1) @@ -713,7 +665,7 @@ class FdfParser: self.Rewind() @staticmethod - def __GetIfListCurrentItemStat(IfList): + def _GetIfListCurrentItemStat(IfList): if len(IfList) == 0: return True @@ -735,29 +687,29 @@ class FdfParser: IfList = [] RegionLayoutLine = 0 ReplacedLine = -1 - while self.__GetNextToken(): + while self._GetNextToken(): # Determine section name and the location dependent macro - if self.__GetIfListCurrentItemStat(IfList): - if self.__Token.startswith('['): - Header = self.__Token - if not self.__Token.endswith(']'): - self.__SkipToToken(']') - Header += self.__SkippedChars + if self._GetIfListCurrentItemStat(IfList): + if self._Token.startswith(TAB_SECTION_START): + Header = self._Token + if not self._Token.endswith(TAB_SECTION_END): + self._SkipToToken(TAB_SECTION_END) + Header += self._SkippedChars if Header.find('$(') != -1: raise Warning("macro cannot be used in section header", self.FileName, self.CurrentLineNumber) - self.__SectionHeaderParser(Header) + self._SectionHeaderParser(Header) continue # Replace macros except in RULE section or out of section - elif self.__CurSection and ReplacedLine != self.CurrentLineNumber: + elif self._CurSection and ReplacedLine != self.CurrentLineNumber: ReplacedLine = self.CurrentLineNumber - self.__UndoToken() + self._UndoToken() CurLine = self.Profile.FileLinesList[ReplacedLine - 1] PreIndex = 0 StartPos = CurLine.find('$(', PreIndex) EndPos = CurLine.find(')', StartPos+2) - while StartPos != -1 and EndPos != -1 and self.__Token not in ['!ifdef', '!ifndef', '!if', '!elseif']: - MacroName = CurLine[StartPos+2 : EndPos] - MacorValue = self.__GetMacroValue(MacroName) + while StartPos != -1 and EndPos != -1 and self._Token not in [TAB_IF_DEF, TAB_IF_N_DEF, TAB_IF, TAB_ELSE_IF]: + MacroName = CurLine[StartPos+2: EndPos] + MacorValue = self._GetMacroValue(MacroName) if MacorValue is not None: CurLine = CurLine.replace('$(' + MacroName + ')', MacorValue, 1) if MacorValue.find('$(') != -1: @@ -771,74 +723,74 @@ class FdfParser: self.Profile.FileLinesList[ReplacedLine - 1] = CurLine continue - if self.__Token == 'DEFINE': - if self.__GetIfListCurrentItemStat(IfList): - if not self.__CurSection: + if self._Token == TAB_DEFINE: + if self._GetIfListCurrentItemStat(IfList): + if not self._CurSection: raise Warning("macro cannot be defined in Rule section or out of section", self.FileName, self.CurrentLineNumber) DefineLine = self.CurrentLineNumber - 1 - DefineOffset = self.CurrentOffsetWithinLine - len('DEFINE') - if not self.__GetNextToken(): + DefineOffset = self.CurrentOffsetWithinLine - len(TAB_DEFINE) + if not self._GetNextToken(): raise Warning("expected Macro name", self.FileName, self.CurrentLineNumber) - Macro = self.__Token - if not self.__IsToken( "="): + Macro = self._Token + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - Value = self.__GetExpression() - self.__SetMacroValue(Macro, Value) - self.__WipeOffArea.append(((DefineLine, DefineOffset), (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1))) - elif self.__Token == 'SET': - if not self.__GetIfListCurrentItemStat(IfList): + Value = self._GetExpression() + self._SetMacroValue(Macro, Value) + self._WipeOffArea.append(((DefineLine, DefineOffset), (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1))) + elif self._Token == 'SET': + if not self._GetIfListCurrentItemStat(IfList): continue SetLine = self.CurrentLineNumber - 1 SetOffset = self.CurrentOffsetWithinLine - len('SET') - PcdPair = self.__GetNextPcdSettings() + PcdPair = self._GetNextPcdSettings() PcdName = "%s.%s" % (PcdPair[1], PcdPair[0]) - if not self.__IsToken( "="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - Value = self.__GetExpression() - Value = self.__EvaluateConditional(Value, self.CurrentLineNumber, 'eval', True) + Value = self._GetExpression() + Value = self._EvaluateConditional(Value, self.CurrentLineNumber, 'eval', True) - self.__PcdDict[PcdName] = Value + self._PcdDict[PcdName] = Value self.Profile.PcdDict[PcdPair] = Value self.SetPcdLocalation(PcdPair) FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber) self.Profile.PcdFileLineDict[PcdPair] = FileLineTuple - self.__WipeOffArea.append(((SetLine, SetOffset), (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1))) - elif self.__Token in ('!ifdef', '!ifndef', '!if'): - IfStartPos = (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - len(self.__Token)) + self._WipeOffArea.append(((SetLine, SetOffset), (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1))) + elif self._Token in (TAB_IF_DEF, TAB_IF_N_DEF, TAB_IF): + IfStartPos = (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - len(self._Token)) IfList.append([IfStartPos, None, None]) - CondLabel = self.__Token - Expression = self.__GetExpression() + CondLabel = self._Token + Expression = self._GetExpression() - if CondLabel == '!if': - ConditionSatisfied = self.__EvaluateConditional(Expression, IfList[-1][0][0] + 1, 'eval') + if CondLabel == TAB_IF: + ConditionSatisfied = self._EvaluateConditional(Expression, IfList[-1][0][0] + 1, 'eval') else: - ConditionSatisfied = self.__EvaluateConditional(Expression, IfList[-1][0][0] + 1, 'in') - if CondLabel == '!ifndef': + ConditionSatisfied = self._EvaluateConditional(Expression, IfList[-1][0][0] + 1, 'in') + if CondLabel == TAB_IF_N_DEF: ConditionSatisfied = not ConditionSatisfied BranchDetermined = ConditionSatisfied IfList[-1] = [IfList[-1][0], ConditionSatisfied, BranchDetermined] if ConditionSatisfied: - self.__WipeOffArea.append((IfList[-1][0], (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1))) - elif self.__Token in ('!elseif', '!else'): - ElseStartPos = (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - len(self.__Token)) + self._WipeOffArea.append((IfList[-1][0], (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1))) + elif self._Token in (TAB_ELSE_IF, '!else'): + ElseStartPos = (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - len(self._Token)) if len(IfList) <= 0: raise Warning("Missing !if statement", self.FileName, self.CurrentLineNumber) if IfList[-1][1]: IfList[-1] = [ElseStartPos, False, True] - self.__WipeOffArea.append((ElseStartPos, (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1))) + self._WipeOffArea.append((ElseStartPos, (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1))) else: - self.__WipeOffArea.append((IfList[-1][0], ElseStartPos)) + self._WipeOffArea.append((IfList[-1][0], ElseStartPos)) IfList[-1] = [ElseStartPos, True, IfList[-1][2]] - if self.__Token == '!elseif': - Expression = self.__GetExpression() - ConditionSatisfied = self.__EvaluateConditional(Expression, IfList[-1][0][0] + 1, 'eval') + if self._Token == TAB_ELSE_IF: + Expression = self._GetExpression() + ConditionSatisfied = self._EvaluateConditional(Expression, IfList[-1][0][0] + 1, 'eval') IfList[-1] = [IfList[-1][0], ConditionSatisfied, IfList[-1][2]] if IfList[-1][1]: @@ -846,14 +798,14 @@ class FdfParser: IfList[-1][1] = False else: IfList[-1][2] = True - self.__WipeOffArea.append((IfList[-1][0], (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1))) - elif self.__Token == '!endif': + self._WipeOffArea.append((IfList[-1][0], (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1))) + elif self._Token == '!endif': if len(IfList) <= 0: raise Warning("Missing !if statement", self.FileName, self.CurrentLineNumber) if IfList[-1][1]: - self.__WipeOffArea.append(((self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - len('!endif')), (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1))) + self._WipeOffArea.append(((self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - len('!endif')), (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1))) else: - self.__WipeOffArea.append((IfList[-1][0], (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1))) + self._WipeOffArea.append((IfList[-1][0], (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1))) IfList.pop() elif not IfList: # Don't use PCDs inside conditional directive @@ -862,7 +814,7 @@ class FdfParser: continue SetPcd = ShortcutPcdPattern.match(self.Profile.FileLinesList[self.CurrentLineNumber - 1]) if SetPcd: - self.__PcdDict[SetPcd.group('name')] = SetPcd.group('value') + self._PcdDict[SetPcd.group('name')] = SetPcd.group('value') RegionLayoutLine = self.CurrentLineNumber continue RegionSize = RegionSizePattern.match(self.Profile.FileLinesList[self.CurrentLineNumber - 1]) @@ -873,35 +825,35 @@ class FdfParser: if not RegionSizeGuid: RegionLayoutLine = self.CurrentLineNumber + 1 continue - self.__PcdDict[RegionSizeGuid.group('base')] = RegionSize.group('base') - self.__PcdDict[RegionSizeGuid.group('size')] = RegionSize.group('size') + self._PcdDict[RegionSizeGuid.group('base')] = RegionSize.group('base') + self._PcdDict[RegionSizeGuid.group('size')] = RegionSize.group('size') RegionLayoutLine = self.CurrentLineNumber + 1 if IfList: raise Warning("Missing !endif", self.FileName, self.CurrentLineNumber) self.Rewind() - def __CollectMacroPcd(self): + def _CollectMacroPcd(self): MacroDict = {} # PCD macro MacroDict.update(GlobalData.gPlatformPcds) - MacroDict.update(self.__PcdDict) + MacroDict.update(self._PcdDict) # Lowest priority MacroDict.update(GlobalData.gPlatformDefines) - if self.__CurSection: + if self._CurSection: # Defines macro - ScopeMacro = self.__MacroDict[TAB_COMMON, TAB_COMMON, TAB_COMMON] + ScopeMacro = self._MacroDict[TAB_COMMON, TAB_COMMON, TAB_COMMON] if ScopeMacro: MacroDict.update(ScopeMacro) # Section macro - ScopeMacro = self.__MacroDict[ - self.__CurSection[0], - self.__CurSection[1], - self.__CurSection[2] + ScopeMacro = self._MacroDict[ + self._CurSection[0], + self._CurSection[1], + self._CurSection[2] ] if ScopeMacro: MacroDict.update(ScopeMacro) @@ -912,15 +864,15 @@ class FdfParser: for Item in GlobalData.BuildOptionPcd: if isinstance(Item, tuple): continue - PcdName, TmpValue = Item.split("=") + PcdName, TmpValue = Item.split(TAB_EQUAL_SPLIT) TmpValue = BuildOptionValue(TmpValue, {}) MacroDict[PcdName.strip()] = TmpValue # Highest priority return MacroDict - def __EvaluateConditional(self, Expression, Line, Op = None, Value = None): - MacroPcdDict = self.__CollectMacroPcd() + def _EvaluateConditional(self, Expression, Line, Op = None, Value = None): + MacroPcdDict = self._CollectMacroPcd() if Op == 'eval': try: if Value: @@ -933,7 +885,7 @@ class FdfParser: # the precise number of line and return the evaluation result # EdkLogger.warn('Parser', "Suspicious expression: %s" % str(Excpt), - File=self.FileName, ExtraData=self.__CurrentLine(), + File=self.FileName, ExtraData=self._CurrentLine(), Line=Line) return Excpt.result except Exception as Excpt: @@ -955,10 +907,10 @@ class FdfParser: Expression = Expression[2:-1] return Expression in MacroPcdDict - ## __IsToken() method + ## _IsToken() method # # Check whether input string is found from current char position along - # If found, the string value is put into self.__Token + # If found, the string value is put into self._Token # # @param self The object pointer # @param String The string to search @@ -966,26 +918,26 @@ class FdfParser: # @retval True Successfully find string, file buffer pointer moved forward # @retval False Not able to find string, file buffer pointer not changed # - def __IsToken(self, String, IgnoreCase = False): - self.__SkipWhiteSpace() + def _IsToken(self, String, IgnoreCase = False): + self._SkipWhiteSpace() # Only consider the same line, no multi-line token allowed StartPos = self.CurrentOffsetWithinLine index = -1 if IgnoreCase: - index = self.__CurrentLine()[self.CurrentOffsetWithinLine : ].upper().find(String.upper()) + index = self._CurrentLine()[self.CurrentOffsetWithinLine: ].upper().find(String.upper()) else: - index = self.__CurrentLine()[self.CurrentOffsetWithinLine : ].find(String) + index = self._CurrentLine()[self.CurrentOffsetWithinLine: ].find(String) if index == 0: self.CurrentOffsetWithinLine += len(String) - self.__Token = self.__CurrentLine()[StartPos : self.CurrentOffsetWithinLine] + self._Token = self._CurrentLine()[StartPos: self.CurrentOffsetWithinLine] return True return False - ## __IsKeyword() method + ## _IsKeyword() method # # Check whether input keyword is found from current char position along, whole word only! - # If found, the string value is put into self.__Token + # If found, the string value is put into self._Token # # @param self The object pointer # @param Keyword The string to search @@ -993,117 +945,117 @@ class FdfParser: # @retval True Successfully find string, file buffer pointer moved forward # @retval False Not able to find string, file buffer pointer not changed # - def __IsKeyword(self, KeyWord, IgnoreCase = False): - self.__SkipWhiteSpace() + def _IsKeyword(self, KeyWord, IgnoreCase = False): + self._SkipWhiteSpace() # Only consider the same line, no multi-line token allowed StartPos = self.CurrentOffsetWithinLine index = -1 if IgnoreCase: - index = self.__CurrentLine()[self.CurrentOffsetWithinLine : ].upper().find(KeyWord.upper()) + index = self._CurrentLine()[self.CurrentOffsetWithinLine: ].upper().find(KeyWord.upper()) else: - index = self.__CurrentLine()[self.CurrentOffsetWithinLine : ].find(KeyWord) + index = self._CurrentLine()[self.CurrentOffsetWithinLine: ].find(KeyWord) if index == 0: - followingChar = self.__CurrentLine()[self.CurrentOffsetWithinLine + len(KeyWord)] - if not str(followingChar).isspace() and followingChar not in SEPERATOR_TUPLE: + followingChar = self._CurrentLine()[self.CurrentOffsetWithinLine + len(KeyWord)] + if not str(followingChar).isspace() and followingChar not in SEPARATORS: return False self.CurrentOffsetWithinLine += len(KeyWord) - self.__Token = self.__CurrentLine()[StartPos : self.CurrentOffsetWithinLine] + self._Token = self._CurrentLine()[StartPos: self.CurrentOffsetWithinLine] return True return False - def __GetExpression(self): + def _GetExpression(self): Line = self.Profile.FileLinesList[self.CurrentLineNumber - 1] Index = len(Line) - 1 - while Line[Index] in ['\r', '\n']: + while Line[Index] in [T_CHAR_CR, TAB_LINE_BREAK]: Index -= 1 ExpressionString = self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine:Index+1] self.CurrentOffsetWithinLine += len(ExpressionString) ExpressionString = ExpressionString.strip() return ExpressionString - ## __GetNextWord() method + ## _GetNextWord() method # # Get next C name from file lines - # If found, the string value is put into self.__Token + # If found, the string value is put into self._Token # # @param self The object pointer # @retval True Successfully find a C name string, file buffer pointer moved forward # @retval False Not able to find a C name string, file buffer pointer not changed # - def __GetNextWord(self): - self.__SkipWhiteSpace() - if self.__EndOfFile(): + def _GetNextWord(self): + self._SkipWhiteSpace() + if self._EndOfFile(): return False - TempChar = self.__CurrentChar() + TempChar = self._CurrentChar() StartPos = self.CurrentOffsetWithinLine if (TempChar >= 'a' and TempChar <= 'z') or (TempChar >= 'A' and TempChar <= 'Z') or TempChar == '_': - self.__GetOneChar() - while not self.__EndOfLine(): - TempChar = self.__CurrentChar() + self._GetOneChar() + while not self._EndOfLine(): + TempChar = self._CurrentChar() if (TempChar >= 'a' and TempChar <= 'z') or (TempChar >= 'A' and TempChar <= 'Z') \ or (TempChar >= '0' and TempChar <= '9') or TempChar == '_' or TempChar == '-': - self.__GetOneChar() + self._GetOneChar() else: break - self.__Token = self.__CurrentLine()[StartPos : self.CurrentOffsetWithinLine] + self._Token = self._CurrentLine()[StartPos: self.CurrentOffsetWithinLine] return True return False - def __GetNextPcdWord(self): - self.__SkipWhiteSpace() - if self.__EndOfFile(): + def _GetNextPcdWord(self): + self._SkipWhiteSpace() + if self._EndOfFile(): return False - TempChar = self.__CurrentChar() + TempChar = self._CurrentChar() StartPos = self.CurrentOffsetWithinLine - if (TempChar >= 'a' and TempChar <= 'z') or (TempChar >= 'A' and TempChar <= 'Z') or TempChar == '_' or TempChar == '[' or TempChar == ']': - self.__GetOneChar() - while not self.__EndOfLine(): - TempChar = self.__CurrentChar() + if (TempChar >= 'a' and TempChar <= 'z') or (TempChar >= 'A' and TempChar <= 'Z') or TempChar == '_' or TempChar == TAB_SECTION_START or TempChar == TAB_SECTION_END: + self._GetOneChar() + while not self._EndOfLine(): + TempChar = self._CurrentChar() if (TempChar >= 'a' and TempChar <= 'z') or (TempChar >= 'A' and TempChar <= 'Z') \ - or (TempChar >= '0' and TempChar <= '9') or TempChar == '_' or TempChar == '-' or TempChar == '[' or TempChar == ']': - self.__GetOneChar() + or (TempChar >= '0' and TempChar <= '9') or TempChar == '_' or TempChar == '-' or TempChar == TAB_SECTION_START or TempChar == TAB_SECTION_END: + self._GetOneChar() else: break - self.__Token = self.__CurrentLine()[StartPos : self.CurrentOffsetWithinLine] + self._Token = self._CurrentLine()[StartPos: self.CurrentOffsetWithinLine] return True return False - ## __GetNextToken() method + ## _GetNextToken() method # # Get next token unit before a seperator - # If found, the string value is put into self.__Token + # If found, the string value is put into self._Token # # @param self The object pointer # @retval True Successfully find a token unit, file buffer pointer moved forward # @retval False Not able to find a token unit, file buffer pointer not changed # - def __GetNextToken(self): + def _GetNextToken(self): # Skip leading spaces, if exist. - self.__SkipWhiteSpace() - if self.__EndOfFile(): + self._SkipWhiteSpace() + if self._EndOfFile(): return False # Record the token start position, the position of the first non-space char. StartPos = self.CurrentOffsetWithinLine StartLine = self.CurrentLineNumber while StartLine == self.CurrentLineNumber: - TempChar = self.__CurrentChar() + TempChar = self._CurrentChar() # Try to find the end char that is not a space and not in seperator tuple. # That is, when we got a space or any char in the tuple, we got the end of token. - if not str(TempChar).isspace() and TempChar not in SEPERATOR_TUPLE: - self.__GetOneChar() + if not str(TempChar).isspace() and TempChar not in SEPARATORS: + self._GetOneChar() # if we happen to meet a seperator as the first char, we must proceed to get it. # That is, we get a token that is a seperator char. nomally it is the boundary of other tokens. - elif StartPos == self.CurrentOffsetWithinLine and TempChar in SEPERATOR_TUPLE: - self.__GetOneChar() + elif StartPos == self.CurrentOffsetWithinLine and TempChar in SEPARATORS: + self._GetOneChar() break else: break @@ -1113,35 +1065,34 @@ class FdfParser: EndPos = self.CurrentOffsetWithinLine if self.CurrentLineNumber != StartLine: EndPos = len(self.Profile.FileLinesList[StartLine-1]) - self.__Token = self.Profile.FileLinesList[StartLine-1][StartPos : EndPos] - if self.__Token.lower() in [TAB_IF, TAB_END_IF, TAB_ELSE_IF, TAB_ELSE, TAB_IF_DEF, TAB_IF_N_DEF, TAB_ERROR, TAB_INCLUDE]: - self.__Token = self.__Token.lower() + self._Token = self.Profile.FileLinesList[StartLine-1][StartPos: EndPos] + if self._Token.lower() in [TAB_IF, TAB_END_IF, TAB_ELSE_IF, TAB_ELSE, TAB_IF_DEF, TAB_IF_N_DEF, TAB_ERROR, TAB_INCLUDE]: + self._Token = self._Token.lower() if StartPos != self.CurrentOffsetWithinLine: return True else: return False - ## __GetNextGuid() method + ## _GetNextGuid() method # # Get next token unit before a seperator - # If found, the GUID string is put into self.__Token + # If found, the GUID string is put into self._Token # # @param self The object pointer # @retval True Successfully find a registry format GUID, file buffer pointer moved forward # @retval False Not able to find a registry format GUID, file buffer pointer not changed # - def __GetNextGuid(self): - - if not self.__GetNextToken(): + def _GetNextGuid(self): + if not self._GetNextToken(): return False - if gGuidPattern.match(self.__Token) is not None: + if gGuidPattern.match(self._Token) is not None: return True else: - self.__UndoToken() + self._UndoToken() return False @staticmethod - def __Verify(Name, Value, Scope): + def _Verify(Name, Value, Scope): # value verification only applies to numeric values. if Scope not in TAB_PCD_NUMERIC_TYPES: return @@ -1157,17 +1108,17 @@ class FdfParser: EdkLogger.error("FdfParser", FORMAT_INVALID, "Too large value for %s." % Name) return True - ## __UndoToken() method + ## _UndoToken() method # # Go back one token unit in file buffer # # @param self The object pointer # - def __UndoToken(self): - self.__UndoOneChar() - while self.__CurrentChar().isspace(): - if not self.__UndoOneChar(): - self.__GetOneChar() + def _UndoToken(self): + self._UndoOneChar() + while self._CurrentChar().isspace(): + if not self._UndoOneChar(): + self._GetOneChar() return @@ -1175,118 +1126,118 @@ class FdfParser: CurrentLine = self.CurrentLineNumber while CurrentLine == self.CurrentLineNumber: - TempChar = self.__CurrentChar() + TempChar = self._CurrentChar() # Try to find the end char that is not a space and not in seperator tuple. # That is, when we got a space or any char in the tuple, we got the end of token. - if not str(TempChar).isspace() and not TempChar in SEPERATOR_TUPLE: - if not self.__UndoOneChar(): + if not str(TempChar).isspace() and not TempChar in SEPARATORS: + if not self._UndoOneChar(): return # if we happen to meet a seperator as the first char, we must proceed to get it. # That is, we get a token that is a seperator char. nomally it is the boundary of other tokens. - elif StartPos == self.CurrentOffsetWithinLine and TempChar in SEPERATOR_TUPLE: + elif StartPos == self.CurrentOffsetWithinLine and TempChar in SEPARATORS: return else: break - self.__GetOneChar() + self._GetOneChar() - ## __GetNextHexNumber() method + ## _GetNextHexNumber() method # # Get next HEX data before a seperator - # If found, the HEX data is put into self.__Token + # If found, the HEX data is put into self._Token # # @param self The object pointer # @retval True Successfully find a HEX data, file buffer pointer moved forward # @retval False Not able to find a HEX data, file buffer pointer not changed # - def __GetNextHexNumber(self): - if not self.__GetNextToken(): + def _GetNextHexNumber(self): + if not self._GetNextToken(): return False - if gHexPatternAll.match(self.__Token): + if gHexPatternAll.match(self._Token): return True else: - self.__UndoToken() + self._UndoToken() return False - ## __GetNextDecimalNumber() method + ## _GetNextDecimalNumber() method # # Get next decimal data before a seperator - # If found, the decimal data is put into self.__Token + # If found, the decimal data is put into self._Token # # @param self The object pointer # @retval True Successfully find a decimal data, file buffer pointer moved forward # @retval False Not able to find a decimal data, file buffer pointer not changed # - def __GetNextDecimalNumber(self): - if not self.__GetNextToken(): + def _GetNextDecimalNumber(self): + if not self._GetNextToken(): return False - if self.__Token.isdigit(): + if self._Token.isdigit(): return True else: - self.__UndoToken() + self._UndoToken() return False - def __GetNextPcdSettings(self): - if not self.__GetNextWord(): + def _GetNextPcdSettings(self): + if not self._GetNextWord(): raise Warning("expected format of .", self.FileName, self.CurrentLineNumber) - pcdTokenSpaceCName = self.__Token + pcdTokenSpaceCName = self._Token - if not self.__IsToken( "."): + if not self._IsToken(TAB_SPLIT): raise Warning("expected format of .", self.FileName, self.CurrentLineNumber) - if not self.__GetNextWord(): + if not self._GetNextWord(): raise Warning("expected format of .", self.FileName, self.CurrentLineNumber) - pcdCName = self.__Token + pcdCName = self._Token Fields = [] - while self.__IsToken("."): - if not self.__GetNextPcdWord(): + while self._IsToken(TAB_SPLIT): + if not self._GetNextPcdWord(): raise Warning("expected format of .", self.FileName, self.CurrentLineNumber) - Fields.append(self.__Token) + Fields.append(self._Token) - return (pcdCName, pcdTokenSpaceCName,".".join(Fields)) + return (pcdCName, pcdTokenSpaceCName,TAB_SPLIT.join(Fields)) - ## __GetStringData() method + ## _GetStringData() method # # Get string contents quoted in "" - # If found, the decimal data is put into self.__Token + # If found, the decimal data is put into self._Token # # @param self The object pointer # @retval True Successfully find a string data, file buffer pointer moved forward # @retval False Not able to find a string data, file buffer pointer not changed # - def __GetStringData(self): - if self.__Token.startswith("\"") or self.__Token.startswith("L\""): - self.__UndoToken() - self.__SkipToToken("\"") + def _GetStringData(self): + if self._Token.startswith(T_CHAR_DOUBLE_QUOTE) or self._Token.startswith("L\""): + self._UndoToken() + self._SkipToToken(T_CHAR_DOUBLE_QUOTE) currentLineNumber = self.CurrentLineNumber - if not self.__SkipToToken("\""): + if not self._SkipToToken(T_CHAR_DOUBLE_QUOTE): raise Warning("Missing Quote \" for String", self.FileName, self.CurrentLineNumber) if currentLineNumber != self.CurrentLineNumber: raise Warning("Missing Quote \" for String", self.FileName, self.CurrentLineNumber) - self.__Token = self.__SkippedChars.rstrip('\"') + self._Token = self._SkippedChars.rstrip(T_CHAR_DOUBLE_QUOTE) return True - elif self.__Token.startswith("\'") or self.__Token.startswith("L\'"): - self.__UndoToken() - self.__SkipToToken("\'") + elif self._Token.startswith(T_CHAR_SINGLE_QUOTE) or self._Token.startswith("L\'"): + self._UndoToken() + self._SkipToToken(T_CHAR_SINGLE_QUOTE) currentLineNumber = self.CurrentLineNumber - if not self.__SkipToToken("\'"): + if not self._SkipToToken(T_CHAR_SINGLE_QUOTE): raise Warning("Missing Quote \' for String", self.FileName, self.CurrentLineNumber) if currentLineNumber != self.CurrentLineNumber: raise Warning("Missing Quote \' for String", self.FileName, self.CurrentLineNumber) - self.__Token = self.__SkippedChars.rstrip('\'') + self._Token = self._SkippedChars.rstrip(T_CHAR_SINGLE_QUOTE) return True else: return False - ## __SkipToToken() method + ## _SkipToToken() method # # Search forward in file buffer for the string - # The skipped chars are put into self.__SkippedChars + # The skipped chars are put into self._SkippedChars # # @param self The object pointer # @param String The string to search @@ -1294,25 +1245,25 @@ class FdfParser: # @retval True Successfully find the string, file buffer pointer moved forward # @retval False Not able to find the string, file buffer pointer not changed # - def __SkipToToken(self, String, IgnoreCase = False): + def _SkipToToken(self, String, IgnoreCase = False): StartPos = self.GetFileBufferPos() - self.__SkippedChars = "" - while not self.__EndOfFile(): + self._SkippedChars = "" + while not self._EndOfFile(): index = -1 if IgnoreCase: - index = self.__CurrentLine()[self.CurrentOffsetWithinLine : ].upper().find(String.upper()) + index = self._CurrentLine()[self.CurrentOffsetWithinLine: ].upper().find(String.upper()) else: - index = self.__CurrentLine()[self.CurrentOffsetWithinLine : ].find(String) + index = self._CurrentLine()[self.CurrentOffsetWithinLine: ].find(String) if index == 0: self.CurrentOffsetWithinLine += len(String) - self.__SkippedChars += String + self._SkippedChars += String return True - self.__SkippedChars += str(self.__CurrentChar()) - self.__GetOneChar() + self._SkippedChars += str(self._CurrentChar()) + self._GetOneChar() - self.SetFileBufferPos( StartPos) - self.__SkippedChars = "" + self.SetFileBufferPos(StartPos) + self._SkippedChars = "" return False ## GetFileBufferPos() method @@ -1343,18 +1294,18 @@ class FdfParser: # @param self The object pointer # def Preprocess(self): - self.__StringToList() + self._StringToList() self.PreprocessFile() self.PreprocessIncludeFile() - self.__StringToList() + self._StringToList() self.PreprocessFile() self.PreprocessConditionalStatement() - self.__StringToList() - for Pos in self.__WipeOffArea: - self.__ReplaceFragment(Pos[0], Pos[1]) + self._StringToList() + for Pos in self._WipeOffArea: + self._ReplaceFragment(Pos[0], Pos[1]) self.Profile.FileLinesList = ["".join(list) for list in self.Profile.FileLinesList] - while self.__GetDefines(): + while self._GetDefines(): pass ## ParseFile() method @@ -1365,19 +1316,18 @@ class FdfParser: # @param self The object pointer # def ParseFile(self): - try: self.Preprocess() - self.__GetError() + self._GetError() # # Keep processing sections of the FDF until no new sections or a syntax error is found # - while self.__GetFd() or self.__GetFv() or self.__GetFmp() or self.__GetCapsule() or self.__GetVtf() or self.__GetRule() or self.__GetOptionRom(): + while self._GetFd() or self._GetFv() or self._GetFmp() or self._GetCapsule() or self._GetVtf() or self._GetRule() or self._GetOptionRom(): pass except Warning as X: - self.__UndoToken() - #'\n\tGot Token: \"%s\" from File %s\n' % (self.__Token, FileLineTuple[0]) + \ + self._UndoToken() + #'\n\tGot Token: \"%s\" from File %s\n' % (self._Token, FileLineTuple[0]) + \ # At this point, the closest parent would be the included file itself Profile = GetParentAtLine(X.OriginalLineNumber) if Profile is not None: @@ -1386,7 +1336,7 @@ class FdfParser: else: FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber) X.Message += ' near line %d, column %d: %s' \ - % (FileLineTuple[1], self.CurrentOffsetWithinLine + 1, self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :].rstrip('\n').rstrip('\r')) + % (FileLineTuple[1], self.CurrentOffsetWithinLine + 1, self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine:].rstrip(TAB_LINE_BREAK).rstrip(T_CHAR_CR)) raise ## SectionParser() method @@ -1403,7 +1353,7 @@ class FdfParser: and not S.startswith("[VTF.") and not S.startswith("[RULE.") and not S.startswith("[OPTIONROM.") and not S.startswith('[FMPPAYLOAD.'): raise Warning("Unknown section or section appear sequence error (The correct sequence should be [DEFINES], [FD.], [FV.], [Capsule.], [VTF.], [Rule.], [OptionRom.], [FMPPAYLOAD.])", self.FileName, self.CurrentLineNumber) - ## __GetDefines() method + ## _GetDefines() method # # Get Defines section contents and store its data into AllMacrosList # @@ -1411,56 +1361,55 @@ class FdfParser: # @retval True Successfully find a Defines # @retval False Not able to find a Defines # - def __GetDefines(self): - - if not self.__GetNextToken(): + def _GetDefines(self): + if not self._GetNextToken(): return False - S = self.__Token.upper() - if S.startswith("[") and not S.startswith("[DEFINES"): + S = self._Token.upper() + if S.startswith(TAB_SECTION_START) and not S.startswith("[DEFINES"): self.SectionParser(S) - self.__UndoToken() + self._UndoToken() return False - self.__UndoToken() - if not self.__IsToken("[DEFINES", True): + self._UndoToken() + if not self._IsToken("[DEFINES", True): FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber) #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \ - # % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine) + # % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine:], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine) raise Warning("expected [DEFINES", self.FileName, self.CurrentLineNumber) - if not self.__IsToken( "]"): + if not self._IsToken(TAB_SECTION_END): raise Warning("expected ']'", self.FileName, self.CurrentLineNumber) - while self.__GetNextWord(): + while self._GetNextWord(): # handle the SET statement - if self.__Token == 'SET': - self.__UndoToken() - self.__GetSetStatement(None) + if self._Token == 'SET': + self._UndoToken() + self._GetSetStatement(None) continue - Macro = self.__Token + Macro = self._Token - if not self.__IsToken("="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken() or self.__Token.startswith('['): + if not self._GetNextToken() or self._Token.startswith(TAB_SECTION_START): raise Warning("expected MACRO value", self.FileName, self.CurrentLineNumber) - Value = self.__Token + Value = self._Token return False - ##__GetError() method - def __GetError(self): + ##_GetError() method + def _GetError(self): #save the Current information CurrentLine = self.CurrentLineNumber CurrentOffset = self.CurrentOffsetWithinLine - while self.__GetNextToken(): - if self.__Token == TAB_ERROR: - EdkLogger.error('FdfParser', ERROR_STATEMENT, self.__CurrentLine().replace(TAB_ERROR, '', 1), File=self.FileName, Line=self.CurrentLineNumber) + while self._GetNextToken(): + if self._Token == TAB_ERROR: + EdkLogger.error('FdfParser', ERROR_STATEMENT, self._CurrentLine().replace(TAB_ERROR, '', 1), File=self.FileName, Line=self.CurrentLineNumber) self.CurrentLineNumber = CurrentLine self.CurrentOffsetWithinLine = CurrentOffset - ## __GetFd() method + ## _GetFd() method # # Get FD section contents and store its data into FD dictionary of self.Profile # @@ -1468,27 +1417,26 @@ class FdfParser: # @retval True Successfully find a FD # @retval False Not able to find a FD # - def __GetFd(self): - - if not self.__GetNextToken(): + def _GetFd(self): + if not self._GetNextToken(): return False - S = self.__Token.upper() - if S.startswith("[") and not S.startswith("[FD."): + S = self._Token.upper() + if S.startswith(TAB_SECTION_START) and not S.startswith("[FD."): if not S.startswith("[FV.") and not S.startswith('[FMPPAYLOAD.') and not S.startswith("[CAPSULE.") \ and not S.startswith("[VTF.") and not S.startswith("[RULE.") and not S.startswith("[OPTIONROM."): raise Warning("Unknown section", self.FileName, self.CurrentLineNumber) - self.__UndoToken() + self._UndoToken() return False - self.__UndoToken() - if not self.__IsToken("[FD.", True): + self._UndoToken() + if not self._IsToken("[FD.", True): FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber) #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \ - # % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine) + # % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine:], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine) raise Warning("expected [FD.]", self.FileName, self.CurrentLineNumber) - FdName = self.__GetUiName() + FdName = self._GetUiName() if FdName == "": if len (self.Profile.FdDict) == 0: FdName = GenFdsGlobalVariable.PlatformName @@ -1502,56 +1450,56 @@ class FdfParser: if self.CurrentFdName in self.Profile.FdDict: raise Warning("Unexpected the same FD name", self.FileName, self.CurrentLineNumber) - if not self.__IsToken( "]"): + if not self._IsToken(TAB_SECTION_END): raise Warning("expected ']'", self.FileName, self.CurrentLineNumber) - FdObj = Fd.FD() + FdObj = FD() FdObj.FdUiName = self.CurrentFdName self.Profile.FdDict[self.CurrentFdName] = FdObj if len (self.Profile.FdDict) > 1 and self.Profile.FdNameNotSet: raise Warning("expected all FDs have their name", self.FileName, self.CurrentLineNumber) - Status = self.__GetCreateFile(FdObj) + Status = self._GetCreateFile(FdObj) if not Status: raise Warning("FD name error", self.FileName, self.CurrentLineNumber) - while self.__GetTokenStatements(FdObj): + while self._GetTokenStatements(FdObj): pass for Attr in ("BaseAddress", "Size", "ErasePolarity"): if getattr(FdObj, Attr) is None: - self.__GetNextToken() + self._GetNextToken() raise Warning("Keyword %s missing" % Attr, self.FileName, self.CurrentLineNumber) if not FdObj.BlockSizeList: FdObj.BlockSizeList.append((1, FdObj.Size, None)) - self.__GetDefineStatements(FdObj) + self._GetDefineStatements(FdObj) - self.__GetSetStatements(FdObj) + self._GetSetStatements(FdObj) - if not self.__GetRegionLayout(FdObj): + if not self._GetRegionLayout(FdObj): raise Warning("expected region layout", self.FileName, self.CurrentLineNumber) - while self.__GetRegionLayout(FdObj): + while self._GetRegionLayout(FdObj): pass return True - ## __GetUiName() method + ## _GetUiName() method # # Return the UI name of a section # # @param self The object pointer # @retval FdName UI name # - def __GetUiName(self): + def _GetUiName(self): Name = "" - if self.__GetNextWord(): - Name = self.__Token + if self._GetNextWord(): + Name = self._Token return Name - ## __GetCreateFile() method + ## _GetCreateFile() method # # Return the output file name of object # @@ -1559,16 +1507,15 @@ class FdfParser: # @param Obj object whose data will be stored in file # @retval FdName UI name # - def __GetCreateFile(self, Obj): - - if self.__IsKeyword( "CREATE_FILE"): - if not self.__IsToken( "="): + def _GetCreateFile(self, Obj): + if self._IsKeyword("CREATE_FILE"): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected file name", self.FileName, self.CurrentLineNumber) - FileName = self.__Token + FileName = self._Token Obj.CreateFileName = FileName return True @@ -1576,25 +1523,25 @@ class FdfParser: def SetPcdLocalation(self,pcdpair): self.Profile.PcdLocalDict[pcdpair] = (self.Profile.FileName,self.CurrentLineNumber) - ## __GetTokenStatements() method + ## _GetTokenStatements() method # # Get token statements # # @param self The object pointer # @param Obj for whom token statement is got # - def __GetTokenStatements(self, Obj): - if self.__IsKeyword( "BaseAddress"): - if not self.__IsToken( "="): + def _GetTokenStatements(self, Obj): + if self._IsKeyword("BaseAddress"): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextHexNumber(): + if not self._GetNextHexNumber(): raise Warning("expected Hex base address", self.FileName, self.CurrentLineNumber) - Obj.BaseAddress = self.__Token + Obj.BaseAddress = self._Token - if self.__IsToken( "|"): - pcdPair = self.__GetNextPcdSettings() + if self._IsToken(TAB_VALUE_SPLIT): + pcdPair = self._GetNextPcdSettings() Obj.BaseAddressPcd = pcdPair self.Profile.PcdDict[pcdPair] = Obj.BaseAddress self.SetPcdLocalation(pcdPair) @@ -1602,16 +1549,16 @@ class FdfParser: self.Profile.PcdFileLineDict[pcdPair] = FileLineTuple return True - if self.__IsKeyword( "Size"): - if not self.__IsToken( "="): + if self._IsKeyword("Size"): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextHexNumber(): + if not self._GetNextHexNumber(): raise Warning("expected Hex size", self.FileName, self.CurrentLineNumber) - Size = self.__Token - if self.__IsToken( "|"): - pcdPair = self.__GetNextPcdSettings() + Size = self._Token + if self._IsToken(TAB_VALUE_SPLIT): + pcdPair = self._GetNextPcdSettings() Obj.SizePcd = pcdPair self.Profile.PcdDict[pcdPair] = Size self.SetPcdLocalation(pcdPair) @@ -1620,22 +1567,22 @@ class FdfParser: Obj.Size = long(Size, 0) return True - if self.__IsKeyword( "ErasePolarity"): - if not self.__IsToken( "="): + if self._IsKeyword("ErasePolarity"): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected Erase Polarity", self.FileName, self.CurrentLineNumber) - if self.__Token != "1" and self.__Token != "0": + if self._Token != "1" and self._Token != "0": raise Warning("expected 1 or 0 Erase Polarity", self.FileName, self.CurrentLineNumber) - Obj.ErasePolarity = self.__Token + Obj.ErasePolarity = self._Token return True - return self.__GetBlockStatements(Obj) + return self._GetBlockStatements(Obj) - ## __GetAddressStatements() method + ## _GetAddressStatements() method # # Get address statements # @@ -1644,38 +1591,37 @@ class FdfParser: # @retval True Successfully find # @retval False Not able to find # - def __GetAddressStatements(self, Obj): - - if self.__IsKeyword("BsBaseAddress"): - if not self.__IsToken( "="): + def _GetAddressStatements(self, Obj): + if self._IsKeyword("BsBaseAddress"): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextDecimalNumber() and not self.__GetNextHexNumber(): + if not self._GetNextDecimalNumber() and not self._GetNextHexNumber(): raise Warning("expected address", self.FileName, self.CurrentLineNumber) - BsAddress = long(self.__Token, 0) + BsAddress = long(self._Token, 0) Obj.BsBaseAddress = BsAddress - if self.__IsKeyword("RtBaseAddress"): - if not self.__IsToken( "="): + if self._IsKeyword("RtBaseAddress"): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextDecimalNumber() and not self.__GetNextHexNumber(): + if not self._GetNextDecimalNumber() and not self._GetNextHexNumber(): raise Warning("expected address", self.FileName, self.CurrentLineNumber) - RtAddress = long(self.__Token, 0) + RtAddress = long(self._Token, 0) Obj.RtBaseAddress = RtAddress - ## __GetBlockStatements() method + ## _GetBlockStatements() method # # Get block statements # # @param self The object pointer # @param Obj for whom block statement is got # - def __GetBlockStatements(self, Obj): + def _GetBlockStatements(self, Obj): IsBlock = False - while self.__GetBlockStatement(Obj): + while self._GetBlockStatement(Obj): IsBlock = True Item = Obj.BlockSizeList[-1] @@ -1683,7 +1629,7 @@ class FdfParser: raise Warning("expected block statement", self.FileName, self.CurrentLineNumber) return IsBlock - ## __GetBlockStatement() method + ## _GetBlockStatement() method # # Get block statement # @@ -1692,20 +1638,20 @@ class FdfParser: # @retval True Successfully find # @retval False Not able to find # - def __GetBlockStatement(self, Obj): - if not self.__IsKeyword( "BlockSize"): + def _GetBlockStatement(self, Obj): + if not self._IsKeyword("BlockSize"): return False - if not self.__IsToken( "="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextHexNumber() and not self.__GetNextDecimalNumber(): + if not self._GetNextHexNumber() and not self._GetNextDecimalNumber(): raise Warning("expected Hex or Integer block size", self.FileName, self.CurrentLineNumber) - BlockSize = self.__Token + BlockSize = self._Token BlockSizePcd = None - if self.__IsToken( "|"): - PcdPair = self.__GetNextPcdSettings() + if self._IsToken(TAB_VALUE_SPLIT): + PcdPair = self._GetNextPcdSettings() BlockSizePcd = PcdPair self.Profile.PcdDict[PcdPair] = BlockSize self.SetPcdLocalation(PcdPair) @@ -1714,19 +1660,19 @@ class FdfParser: BlockSize = long(BlockSize, 0) BlockNumber = None - if self.__IsKeyword( "NumBlocks"): - if not self.__IsToken( "="): + if self._IsKeyword("NumBlocks"): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextDecimalNumber() and not self.__GetNextHexNumber(): + if not self._GetNextDecimalNumber() and not self._GetNextHexNumber(): raise Warning("expected block numbers", self.FileName, self.CurrentLineNumber) - BlockNumber = long(self.__Token, 0) + BlockNumber = long(self._Token, 0) Obj.BlockSizeList.append((BlockSize, BlockNumber, BlockSizePcd)) return True - ## __GetDefineStatements() method + ## _GetDefineStatements() method # # Get define statements # @@ -1735,11 +1681,11 @@ class FdfParser: # @retval True Successfully find # @retval False Not able to find # - def __GetDefineStatements(self, Obj): - while self.__GetDefineStatement( Obj): + def _GetDefineStatements(self, Obj): + while self._GetDefineStatement(Obj): pass - ## __GetDefineStatement() method + ## _GetDefineStatement() method # # Get define statement # @@ -1748,24 +1694,24 @@ class FdfParser: # @retval True Successfully find # @retval False Not able to find # - def __GetDefineStatement(self, Obj): - if self.__IsKeyword("DEFINE"): - self.__GetNextToken() - Macro = self.__Token - if not self.__IsToken( "="): + def _GetDefineStatement(self, Obj): + if self._IsKeyword(TAB_DEFINE): + self._GetNextToken() + Macro = self._Token + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected value", self.FileName, self.CurrentLineNumber) - Value = self.__Token + Value = self._Token Macro = '$(' + Macro + ')' Obj.DefineVarDict[Macro] = Value return True return False - ## __GetSetStatements() method + ## _GetSetStatements() method # # Get set statements # @@ -1774,11 +1720,11 @@ class FdfParser: # @retval True Successfully find # @retval False Not able to find # - def __GetSetStatements(self, Obj): - while self.__GetSetStatement(Obj): + def _GetSetStatements(self, Obj): + while self._GetSetStatement(Obj): pass - ## __GetSetStatement() method + ## _GetSetStatement() method # # Get set statement # @@ -1787,15 +1733,15 @@ class FdfParser: # @retval True Successfully find # @retval False Not able to find # - def __GetSetStatement(self, Obj): - if self.__IsKeyword("SET"): - PcdPair = self.__GetNextPcdSettings() + def _GetSetStatement(self, Obj): + if self._IsKeyword("SET"): + PcdPair = self._GetNextPcdSettings() - if not self.__IsToken( "="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - Value = self.__GetExpression() - Value = self.__EvaluateConditional(Value, self.CurrentLineNumber, 'eval', True) + Value = self._GetExpression() + Value = self._EvaluateConditional(Value, self.CurrentLineNumber, 'eval', True) if Obj: Obj.SetVarDict[PcdPair] = Value @@ -1807,19 +1753,19 @@ class FdfParser: return False - ## __CalcRegionExpr(self) + ## _CalcRegionExpr(self) # # Calculate expression for offset or size of a region # # @return: None if invalid expression # Calculated number if successfully # - def __CalcRegionExpr(self): + def _CalcRegionExpr(self): StartPos = self.GetFileBufferPos() Expr = '' PairCount = 0 - while not self.__EndOfFile(): - CurCh = self.__CurrentChar() + while not self._EndOfFile(): + CurCh = self._CurrentChar() if CurCh == '(': PairCount += 1 elif CurCh == ')': @@ -1828,106 +1774,106 @@ class FdfParser: if CurCh in '|\r\n' and PairCount == 0: break Expr += CurCh - self.__GetOneChar() + self._GetOneChar() try: return long( ValueExpression(Expr, - self.__CollectMacroPcd() + self._CollectMacroPcd() )(True), 0) except Exception: self.SetFileBufferPos(StartPos) return None - ## __GetRegionLayout() method + ## _GetRegionLayout() method # # Get region layout for FD # # @param self The object pointer - # @param Fd for whom region is got + # @param theFd for whom region is got # @retval True Successfully find # @retval False Not able to find # - def __GetRegionLayout(self, Fd): - Offset = self.__CalcRegionExpr() + def _GetRegionLayout(self, theFd): + Offset = self._CalcRegionExpr() if Offset is None: return False - RegionObj = Region.Region() + RegionObj = Region() RegionObj.Offset = Offset - Fd.RegionList.append(RegionObj) + theFd.RegionList.append(RegionObj) - if not self.__IsToken( "|"): + if not self._IsToken(TAB_VALUE_SPLIT): raise Warning("expected '|'", self.FileName, self.CurrentLineNumber) - Size = self.__CalcRegionExpr() + Size = self._CalcRegionExpr() if Size is None: raise Warning("expected Region Size", self.FileName, self.CurrentLineNumber) RegionObj.Size = Size - if not self.__GetNextWord(): + if not self._GetNextWord(): return True - if not self.__Token in ("SET", BINARY_FILE_TYPE_FV, "FILE", "DATA", "CAPSULE", "INF"): + if not self._Token in ("SET", BINARY_FILE_TYPE_FV, "FILE", "DATA", "CAPSULE", "INF"): # # If next token is a word which is not a valid FV type, it might be part of [PcdOffset[|PcdSize]] # Or it might be next region's offset described by an expression which starts with a PCD. # PcdOffset[|PcdSize] or OffsetPcdExpression|Size # - self.__UndoToken() - IsRegionPcd = (RegionSizeGuidPattern.match(self.__CurrentLine()[self.CurrentOffsetWithinLine:]) or - RegionOffsetPcdPattern.match(self.__CurrentLine()[self.CurrentOffsetWithinLine:])) + self._UndoToken() + IsRegionPcd = (RegionSizeGuidPattern.match(self._CurrentLine()[self.CurrentOffsetWithinLine:]) or + RegionOffsetPcdPattern.match(self._CurrentLine()[self.CurrentOffsetWithinLine:])) if IsRegionPcd: - RegionObj.PcdOffset = self.__GetNextPcdSettings() - self.Profile.PcdDict[RegionObj.PcdOffset] = "0x%08X" % (RegionObj.Offset + long(Fd.BaseAddress, 0)) + RegionObj.PcdOffset = self._GetNextPcdSettings() + self.Profile.PcdDict[RegionObj.PcdOffset] = "0x%08X" % (RegionObj.Offset + long(theFd.BaseAddress, 0)) self.SetPcdLocalation(RegionObj.PcdOffset) - self.__PcdDict['%s.%s' % (RegionObj.PcdOffset[1], RegionObj.PcdOffset[0])] = "0x%x" % RegionObj.Offset + self._PcdDict['%s.%s' % (RegionObj.PcdOffset[1], RegionObj.PcdOffset[0])] = "0x%x" % RegionObj.Offset FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber) self.Profile.PcdFileLineDict[RegionObj.PcdOffset] = FileLineTuple - if self.__IsToken( "|"): - RegionObj.PcdSize = self.__GetNextPcdSettings() + if self._IsToken(TAB_VALUE_SPLIT): + RegionObj.PcdSize = self._GetNextPcdSettings() self.Profile.PcdDict[RegionObj.PcdSize] = "0x%08X" % RegionObj.Size self.SetPcdLocalation(RegionObj.PcdSize) - self.__PcdDict['%s.%s' % (RegionObj.PcdSize[1], RegionObj.PcdSize[0])] = "0x%x" % RegionObj.Size + self._PcdDict['%s.%s' % (RegionObj.PcdSize[1], RegionObj.PcdSize[0])] = "0x%x" % RegionObj.Size FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber) self.Profile.PcdFileLineDict[RegionObj.PcdSize] = FileLineTuple - if not self.__GetNextWord(): + if not self._GetNextWord(): return True - if self.__Token == "SET": - self.__UndoToken() - self.__GetSetStatements( RegionObj) - if not self.__GetNextWord(): + if self._Token == "SET": + self._UndoToken() + self._GetSetStatements(RegionObj) + if not self._GetNextWord(): return True - elif self.__Token == BINARY_FILE_TYPE_FV: - self.__UndoToken() - self.__GetRegionFvType( RegionObj) + elif self._Token == BINARY_FILE_TYPE_FV: + self._UndoToken() + self._GetRegionFvType(RegionObj) - elif self.__Token == "CAPSULE": - self.__UndoToken() - self.__GetRegionCapType( RegionObj) + elif self._Token == "CAPSULE": + self._UndoToken() + self._GetRegionCapType(RegionObj) - elif self.__Token == "FILE": - self.__UndoToken() - self.__GetRegionFileType(RegionObj) + elif self._Token == "FILE": + self._UndoToken() + self._GetRegionFileType(RegionObj) - elif self.__Token == "INF": - self.__UndoToken() + elif self._Token == "INF": + self._UndoToken() RegionObj.RegionType = "INF" - while self.__IsKeyword("INF"): - self.__UndoToken() - ffsInf = self.__ParseInfStatement() + while self._IsKeyword("INF"): + self._UndoToken() + ffsInf = self._ParseInfStatement() if not ffsInf: break RegionObj.RegionDataList.append(ffsInf) - elif self.__Token == "DATA": - self.__UndoToken() - self.__GetRegionDataType(RegionObj) + elif self._Token == "DATA": + self._UndoToken() + self._GetRegionDataType(RegionObj) else: - self.__UndoToken() - if self.__GetRegionLayout(Fd): + self._UndoToken() + if self._GetRegionLayout(theFd): return True raise Warning("A valid region type was not found. " "Valid types are [SET, FV, CAPSULE, FILE, DATA, INF]. This error occurred", @@ -1935,189 +1881,185 @@ class FdfParser: return True - ## __GetRegionFvType() method + ## _GetRegionFvType() method # # Get region fv data for region # # @param self The object pointer # @param RegionObj for whom region data is got # - def __GetRegionFvType(self, RegionObj): - - if not self.__IsKeyword( BINARY_FILE_TYPE_FV): + def _GetRegionFvType(self, RegionObj): + if not self._IsKeyword(BINARY_FILE_TYPE_FV): raise Warning("expected Keyword BINARY_FILE_TYPE_FV", self.FileName, self.CurrentLineNumber) - if not self.__IsToken( "="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected FV name", self.FileName, self.CurrentLineNumber) RegionObj.RegionType = BINARY_FILE_TYPE_FV - RegionObj.RegionDataList.append((self.__Token).upper()) + RegionObj.RegionDataList.append((self._Token).upper()) - while self.__IsKeyword( BINARY_FILE_TYPE_FV): + while self._IsKeyword(BINARY_FILE_TYPE_FV): - if not self.__IsToken( "="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected FV name", self.FileName, self.CurrentLineNumber) - RegionObj.RegionDataList.append((self.__Token).upper()) + RegionObj.RegionDataList.append((self._Token).upper()) - ## __GetRegionCapType() method + ## _GetRegionCapType() method # # Get region capsule data for region # # @param self The object pointer # @param RegionObj for whom region data is got # - def __GetRegionCapType(self, RegionObj): - - if not self.__IsKeyword("CAPSULE"): + def _GetRegionCapType(self, RegionObj): + if not self._IsKeyword("CAPSULE"): raise Warning("expected Keyword 'CAPSULE'", self.FileName, self.CurrentLineNumber) - if not self.__IsToken("="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected CAPSULE name", self.FileName, self.CurrentLineNumber) RegionObj.RegionType = "CAPSULE" - RegionObj.RegionDataList.append(self.__Token) + RegionObj.RegionDataList.append(self._Token) - while self.__IsKeyword("CAPSULE"): + while self._IsKeyword("CAPSULE"): - if not self.__IsToken("="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected CAPSULE name", self.FileName, self.CurrentLineNumber) - RegionObj.RegionDataList.append(self.__Token) + RegionObj.RegionDataList.append(self._Token) - ## __GetRegionFileType() method + ## _GetRegionFileType() method # # Get region file data for region # # @param self The object pointer # @param RegionObj for whom region data is got # - def __GetRegionFileType(self, RegionObj): - - if not self.__IsKeyword( "FILE"): + def _GetRegionFileType(self, RegionObj): + if not self._IsKeyword("FILE"): raise Warning("expected Keyword 'FILE'", self.FileName, self.CurrentLineNumber) - if not self.__IsToken( "="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected File name", self.FileName, self.CurrentLineNumber) RegionObj.RegionType = "FILE" - RegionObj.RegionDataList.append( self.__Token) + RegionObj.RegionDataList.append(self._Token) - while self.__IsKeyword( "FILE"): + while self._IsKeyword("FILE"): - if not self.__IsToken( "="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected FILE name", self.FileName, self.CurrentLineNumber) - RegionObj.RegionDataList.append(self.__Token) + RegionObj.RegionDataList.append(self._Token) - ## __GetRegionDataType() method + ## _GetRegionDataType() method # # Get region array data for region # # @param self The object pointer # @param RegionObj for whom region data is got # - def __GetRegionDataType(self, RegionObj): - - if not self.__IsKeyword( "DATA"): + def _GetRegionDataType(self, RegionObj): + if not self._IsKeyword("DATA"): raise Warning("expected Region Data type", self.FileName, self.CurrentLineNumber) - if not self.__IsToken( "="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__IsToken( "{"): + if not self._IsToken("{"): raise Warning("expected '{'", self.FileName, self.CurrentLineNumber) - if not self.__GetNextHexNumber(): + if not self._GetNextHexNumber(): raise Warning("expected Hex byte", self.FileName, self.CurrentLineNumber) - if len(self.__Token) > 18: + if len(self._Token) > 18: raise Warning("Hex string can't be converted to a valid UINT64 value", self.FileName, self.CurrentLineNumber) # convert hex string value to byte hex string array - AllString = self.__Token + AllString = self._Token AllStrLen = len (AllString) DataString = "" while AllStrLen > 4: - DataString = DataString + "0x" + AllString[AllStrLen - 2: AllStrLen] + "," + DataString = DataString + "0x" + AllString[AllStrLen - 2: AllStrLen] + TAB_COMMA_SPLIT AllStrLen = AllStrLen - 2 - DataString = DataString + AllString[:AllStrLen] + "," + DataString = DataString + AllString[:AllStrLen] + TAB_COMMA_SPLIT # byte value array - if len (self.__Token) <= 4: - while self.__IsToken(","): - if not self.__GetNextHexNumber(): + if len (self._Token) <= 4: + while self._IsToken(TAB_COMMA_SPLIT): + if not self._GetNextHexNumber(): raise Warning("Invalid Hex number", self.FileName, self.CurrentLineNumber) - if len(self.__Token) > 4: + if len(self._Token) > 4: raise Warning("Hex byte(must be 2 digits) too long", self.FileName, self.CurrentLineNumber) - DataString += self.__Token - DataString += "," + DataString += self._Token + DataString += TAB_COMMA_SPLIT - if not self.__IsToken( "}"): + if not self._IsToken("}"): raise Warning("expected '}'", self.FileName, self.CurrentLineNumber) - DataString = DataString.rstrip(",") + DataString = DataString.rstrip(TAB_COMMA_SPLIT) RegionObj.RegionType = "DATA" - RegionObj.RegionDataList.append( DataString) + RegionObj.RegionDataList.append(DataString) - while self.__IsKeyword( "DATA"): + while self._IsKeyword("DATA"): - if not self.__IsToken( "="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__IsToken( "{"): + if not self._IsToken("{"): raise Warning("expected '{'", self.FileName, self.CurrentLineNumber) - if not self.__GetNextHexNumber(): + if not self._GetNextHexNumber(): raise Warning("expected Hex byte", self.FileName, self.CurrentLineNumber) - if len(self.__Token) > 18: + if len(self._Token) > 18: raise Warning("Hex string can't be converted to a valid UINT64 value", self.FileName, self.CurrentLineNumber) # convert hex string value to byte hex string array - AllString = self.__Token + AllString = self._Token AllStrLen = len (AllString) DataString = "" while AllStrLen > 4: - DataString = DataString + "0x" + AllString[AllStrLen - 2: AllStrLen] + "," + DataString = DataString + "0x" + AllString[AllStrLen - 2: AllStrLen] + TAB_COMMA_SPLIT AllStrLen = AllStrLen - 2 - DataString = DataString + AllString[:AllStrLen] + "," + DataString = DataString + AllString[:AllStrLen] + TAB_COMMA_SPLIT # byte value array - if len (self.__Token) <= 4: - while self.__IsToken(","): - if not self.__GetNextHexNumber(): + if len (self._Token) <= 4: + while self._IsToken(TAB_COMMA_SPLIT): + if not self._GetNextHexNumber(): raise Warning("Invalid Hex number", self.FileName, self.CurrentLineNumber) - if len(self.__Token) > 4: + if len(self._Token) > 4: raise Warning("Hex byte(must be 2 digits) too long", self.FileName, self.CurrentLineNumber) - DataString += self.__Token - DataString += "," + DataString += self._Token + DataString += TAB_COMMA_SPLIT - if not self.__IsToken( "}"): + if not self._IsToken("}"): raise Warning("expected '}'", self.FileName, self.CurrentLineNumber) - DataString = DataString.rstrip(",") - RegionObj.RegionDataList.append( DataString) + DataString = DataString.rstrip(TAB_COMMA_SPLIT) + RegionObj.RegionDataList.append(DataString) - ## __GetFv() method + ## _GetFv() method # # Get FV section contents and store its data into FV dictionary of self.Profile # @@ -2125,68 +2067,68 @@ class FdfParser: # @retval True Successfully find a FV # @retval False Not able to find a FV # - def __GetFv(self): - if not self.__GetNextToken(): + def _GetFv(self): + if not self._GetNextToken(): return False - S = self.__Token.upper() - if S.startswith("[") and not S.startswith("[FV."): + S = self._Token.upper() + if S.startswith(TAB_SECTION_START) and not S.startswith("[FV."): self.SectionParser(S) - self.__UndoToken() + self._UndoToken() return False - self.__UndoToken() - if not self.__IsToken("[FV.", True): + self._UndoToken() + if not self._IsToken("[FV.", True): FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber) #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \ - # % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine) - raise Warning("Unknown Keyword '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) + # % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine:], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine) + raise Warning("Unknown Keyword '%s'" % self._Token, self.FileName, self.CurrentLineNumber) - FvName = self.__GetUiName() + FvName = self._GetUiName() self.CurrentFvName = FvName.upper() - if not self.__IsToken( "]"): + if not self._IsToken(TAB_SECTION_END): raise Warning("expected ']'", self.FileName, self.CurrentLineNumber) - FvObj = Fv.FV() + FvObj = FV() FvObj.UiFvName = self.CurrentFvName self.Profile.FvDict[self.CurrentFvName] = FvObj - Status = self.__GetCreateFile(FvObj) + Status = self._GetCreateFile(FvObj) if not Status: raise Warning("FV name error", self.FileName, self.CurrentLineNumber) - self.__GetDefineStatements(FvObj) + self._GetDefineStatements(FvObj) - self.__GetAddressStatements(FvObj) + self._GetAddressStatements(FvObj) FvObj.FvExtEntryTypeValue = [] FvObj.FvExtEntryType = [] FvObj.FvExtEntryData = [] while True: - self.__GetSetStatements(FvObj) + self._GetSetStatements(FvObj) - if not (self.__GetBlockStatement(FvObj) or self.__GetFvBaseAddress(FvObj) or - self.__GetFvForceRebase(FvObj) or self.__GetFvAlignment(FvObj) or - self.__GetFvAttributes(FvObj) or self.__GetFvNameGuid(FvObj) or - self.__GetFvExtEntryStatement(FvObj) or self.__GetFvNameString(FvObj)): + if not (self._GetBlockStatement(FvObj) or self._GetFvBaseAddress(FvObj) or + self._GetFvForceRebase(FvObj) or self._GetFvAlignment(FvObj) or + self._GetFvAttributes(FvObj) or self._GetFvNameGuid(FvObj) or + self._GetFvExtEntryStatement(FvObj) or self._GetFvNameString(FvObj)): break if FvObj.FvNameString == 'TRUE' and not FvObj.FvNameGuid: raise Warning("FvNameString found but FvNameGuid was not found", self.FileName, self.CurrentLineNumber) - self.__GetAprioriSection(FvObj, FvObj.DefineVarDict.copy()) - self.__GetAprioriSection(FvObj, FvObj.DefineVarDict.copy()) + self._GetAprioriSection(FvObj, FvObj.DefineVarDict.copy()) + self._GetAprioriSection(FvObj, FvObj.DefineVarDict.copy()) while True: - isInf = self.__GetInfStatement(FvObj) - isFile = self.__GetFileStatement(FvObj, MacroDict = FvObj.DefineVarDict.copy()) + isInf = self._GetInfStatement(FvObj) + isFile = self._GetFileStatement(FvObj, MacroDict = FvObj.DefineVarDict.copy()) if not isInf and not isFile: break return True - ## __GetFvAlignment() method + ## _GetFvAlignment() method # # Get alignment for FV # @@ -2195,26 +2137,25 @@ class FdfParser: # @retval True Successfully find a alignment statement # @retval False Not able to find a alignment statement # - def __GetFvAlignment(self, Obj): - - if not self.__IsKeyword( "FvAlignment"): + def _GetFvAlignment(self, Obj): + if not self._IsKeyword("FvAlignment"): return False - if not self.__IsToken( "="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected alignment value", self.FileName, self.CurrentLineNumber) - if self.__Token.upper() not in ("1", "2", "4", "8", "16", "32", "64", "128", "256", "512", \ + if self._Token.upper() not in ("1", "2", "4", "8", "16", "32", "64", "128", "256", "512", \ "1K", "2K", "4K", "8K", "16K", "32K", "64K", "128K", "256K", "512K", \ "1M", "2M", "4M", "8M", "16M", "32M", "64M", "128M", "256M", "512M", \ "1G", "2G"): - raise Warning("Unknown alignment value '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) - Obj.FvAlignment = self.__Token + raise Warning("Unknown alignment value '%s'" % self._Token, self.FileName, self.CurrentLineNumber) + Obj.FvAlignment = self._Token return True - ## __GetFvBaseAddress() method + ## _GetFvBaseAddress() method # # Get BaseAddress for FV # @@ -2223,23 +2164,22 @@ class FdfParser: # @retval True Successfully find a FvBaseAddress statement # @retval False Not able to find a FvBaseAddress statement # - def __GetFvBaseAddress(self, Obj): - - if not self.__IsKeyword("FvBaseAddress"): + def _GetFvBaseAddress(self, Obj): + if not self._IsKeyword("FvBaseAddress"): return False - if not self.__IsToken( "="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected FV base address value", self.FileName, self.CurrentLineNumber) - if not BaseAddrValuePattern.match(self.__Token.upper()): - raise Warning("Unknown FV base address value '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) - Obj.FvBaseAddress = self.__Token + if not BaseAddrValuePattern.match(self._Token.upper()): + raise Warning("Unknown FV base address value '%s'" % self._Token, self.FileName, self.CurrentLineNumber) + Obj.FvBaseAddress = self._Token return True - ## __GetFvForceRebase() method + ## _GetFvForceRebase() method # # Get FvForceRebase for FV # @@ -2248,23 +2188,22 @@ class FdfParser: # @retval True Successfully find a FvForceRebase statement # @retval False Not able to find a FvForceRebase statement # - def __GetFvForceRebase(self, Obj): - - if not self.__IsKeyword("FvForceRebase"): + def _GetFvForceRebase(self, Obj): + if not self._IsKeyword("FvForceRebase"): return False - if not self.__IsToken( "="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected FvForceRebase value", self.FileName, self.CurrentLineNumber) - if self.__Token.upper() not in ["TRUE", "FALSE", "0", "0X0", "0X00", "1", "0X1", "0X01"]: - raise Warning("Unknown FvForceRebase value '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) + if self._Token.upper() not in ["TRUE", "FALSE", "0", "0X0", "0X00", "1", "0X1", "0X01"]: + raise Warning("Unknown FvForceRebase value '%s'" % self._Token, self.FileName, self.CurrentLineNumber) - if self.__Token.upper() in ["TRUE", "1", "0X1", "0X01"]: + if self._Token.upper() in ["TRUE", "1", "0X1", "0X01"]: Obj.FvForceRebase = True - elif self.__Token.upper() in ["FALSE", "0", "0X0", "0X00"]: + elif self._Token.upper() in ["FALSE", "0", "0X0", "0X00"]: Obj.FvForceRebase = False else: Obj.FvForceRebase = None @@ -2272,7 +2211,7 @@ class FdfParser: return True - ## __GetFvAttributes() method + ## _GetFvAttributes() method # # Get attributes for FV # @@ -2280,31 +2219,31 @@ class FdfParser: # @param Obj for whom attribute is got # @retval None # - def __GetFvAttributes(self, FvObj): + def _GetFvAttributes(self, FvObj): IsWordToken = False - while self.__GetNextWord(): + while self._GetNextWord(): IsWordToken = True - name = self.__Token + name = self._Token if name not in ("ERASE_POLARITY", "MEMORY_MAPPED", \ "STICKY_WRITE", "LOCK_CAP", "LOCK_STATUS", "WRITE_ENABLED_CAP", \ "WRITE_DISABLED_CAP", "WRITE_STATUS", "READ_ENABLED_CAP", \ "READ_DISABLED_CAP", "READ_STATUS", "READ_LOCK_CAP", \ "READ_LOCK_STATUS", "WRITE_LOCK_CAP", "WRITE_LOCK_STATUS", \ "WRITE_POLICY_RELIABLE", "WEAK_ALIGNMENT", "FvUsedSizeEnable"): - self.__UndoToken() + self._UndoToken() return False - if not self.__IsToken( "="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken() or self.__Token.upper() not in ("TRUE", "FALSE", "1", "0"): + if not self._GetNextToken() or self._Token.upper() not in ("TRUE", "FALSE", "1", "0"): raise Warning("expected TRUE/FALSE (1/0)", self.FileName, self.CurrentLineNumber) - FvObj.FvAttributeDict[name] = self.__Token + FvObj.FvAttributeDict[name] = self._Token return IsWordToken - ## __GetFvNameGuid() method + ## _GetFvNameGuid() method # # Get FV GUID for FV # @@ -2312,110 +2251,107 @@ class FdfParser: # @param Obj for whom GUID is got # @retval None # - def __GetFvNameGuid(self, FvObj): - - if not self.__IsKeyword( "FvNameGuid"): + def _GetFvNameGuid(self, FvObj): + if not self._IsKeyword("FvNameGuid"): return False - if not self.__IsToken( "="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextGuid(): + if not self._GetNextGuid(): raise Warning("expected FV GUID value", self.FileName, self.CurrentLineNumber) - FvObj.FvNameGuid = self.__Token + FvObj.FvNameGuid = self._Token return True - def __GetFvNameString(self, FvObj): - - if not self.__IsKeyword( "FvNameString"): + def _GetFvNameString(self, FvObj): + if not self._IsKeyword("FvNameString"): return False - if not self.__IsToken( "="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken() or self.__Token not in ('TRUE', 'FALSE'): + if not self._GetNextToken() or self._Token not in ('TRUE', 'FALSE'): raise Warning("expected TRUE or FALSE for FvNameString", self.FileName, self.CurrentLineNumber) - FvObj.FvNameString = self.__Token + FvObj.FvNameString = self._Token return True - def __GetFvExtEntryStatement(self, FvObj): - - if not (self.__IsKeyword( "FV_EXT_ENTRY") or self.__IsKeyword( "FV_EXT_ENTRY_TYPE")): + def _GetFvExtEntryStatement(self, FvObj): + if not (self._IsKeyword("FV_EXT_ENTRY") or self._IsKeyword("FV_EXT_ENTRY_TYPE")): return False - if not self.__IsKeyword ("TYPE"): + if not self._IsKeyword ("TYPE"): raise Warning("expected 'TYPE'", self.FileName, self.CurrentLineNumber) - if not self.__IsToken( "="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextHexNumber() and not self.__GetNextDecimalNumber(): + if not self._GetNextHexNumber() and not self._GetNextDecimalNumber(): raise Warning("expected Hex FV extension entry type value At Line ", self.FileName, self.CurrentLineNumber) - FvObj.FvExtEntryTypeValue.append(self.__Token) + FvObj.FvExtEntryTypeValue.append(self._Token) - if not self.__IsToken( "{"): + if not self._IsToken("{"): raise Warning("expected '{'", self.FileName, self.CurrentLineNumber) - if not self.__IsKeyword ("FILE") and not self.__IsKeyword ("DATA"): + if not self._IsKeyword ("FILE") and not self._IsKeyword ("DATA"): raise Warning("expected 'FILE' or 'DATA'", self.FileName, self.CurrentLineNumber) - FvObj.FvExtEntryType.append(self.__Token) + FvObj.FvExtEntryType.append(self._Token) - if self.__Token == 'DATA': + if self._Token == 'DATA': - if not self.__IsToken( "="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__IsToken( "{"): + if not self._IsToken("{"): raise Warning("expected '{'", self.FileName, self.CurrentLineNumber) - if not self.__GetNextHexNumber(): + if not self._GetNextHexNumber(): raise Warning("expected Hex byte", self.FileName, self.CurrentLineNumber) - if len(self.__Token) > 4: + if len(self._Token) > 4: raise Warning("Hex byte(must be 2 digits) too long", self.FileName, self.CurrentLineNumber) - DataString = self.__Token - DataString += "," + DataString = self._Token + DataString += TAB_COMMA_SPLIT - while self.__IsToken(","): - if not self.__GetNextHexNumber(): + while self._IsToken(TAB_COMMA_SPLIT): + if not self._GetNextHexNumber(): raise Warning("Invalid Hex number", self.FileName, self.CurrentLineNumber) - if len(self.__Token) > 4: + if len(self._Token) > 4: raise Warning("Hex byte(must be 2 digits) too long", self.FileName, self.CurrentLineNumber) - DataString += self.__Token - DataString += "," + DataString += self._Token + DataString += TAB_COMMA_SPLIT - if not self.__IsToken( "}"): + if not self._IsToken("}"): raise Warning("expected '}'", self.FileName, self.CurrentLineNumber) - if not self.__IsToken( "}"): + if not self._IsToken("}"): raise Warning("expected '}'", self.FileName, self.CurrentLineNumber) - DataString = DataString.rstrip(",") + DataString = DataString.rstrip(TAB_COMMA_SPLIT) FvObj.FvExtEntryData.append(DataString) - if self.__Token == 'FILE': + if self._Token == 'FILE': - if not self.__IsToken( "="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected FV Extension Entry file path At Line ", self.FileName, self.CurrentLineNumber) - FvObj.FvExtEntryData.append(self.__Token) + FvObj.FvExtEntryData.append(self._Token) - if not self.__IsToken( "}"): + if not self._IsToken("}"): raise Warning("expected '}'", self.FileName, self.CurrentLineNumber) return True - ## __GetAprioriSection() method + ## _GetAprioriSection() method # # Get token statements # @@ -2425,56 +2361,55 @@ class FdfParser: # @retval True Successfully find apriori statement # @retval False Not able to find apriori statement # - def __GetAprioriSection(self, FvObj, MacroDict = {}): - - if not self.__IsKeyword( "APRIORI"): + def _GetAprioriSection(self, FvObj, MacroDict = {}): + if not self._IsKeyword("APRIORI"): return False - if not self.__IsKeyword("PEI") and not self.__IsKeyword("DXE"): + if not self._IsKeyword("PEI") and not self._IsKeyword("DXE"): raise Warning("expected Apriori file type", self.FileName, self.CurrentLineNumber) - AprType = self.__Token + AprType = self._Token - if not self.__IsToken( "{"): + if not self._IsToken("{"): raise Warning("expected '{'", self.FileName, self.CurrentLineNumber) - AprSectionObj = AprioriSection.AprioriSection() + AprSectionObj = AprioriSection() AprSectionObj.AprioriType = AprType - self.__GetDefineStatements(AprSectionObj) + self._GetDefineStatements(AprSectionObj) MacroDict.update(AprSectionObj.DefineVarDict) while True: - IsInf = self.__GetInfStatement(AprSectionObj) - IsFile = self.__GetFileStatement( AprSectionObj) + IsInf = self._GetInfStatement(AprSectionObj) + IsFile = self._GetFileStatement(AprSectionObj) if not IsInf and not IsFile: break - if not self.__IsToken( "}"): + if not self._IsToken("}"): raise Warning("expected '}'", self.FileName, self.CurrentLineNumber) FvObj.AprioriSectionList.append(AprSectionObj) return True - def __ParseInfStatement(self): - if not self.__IsKeyword("INF"): + def _ParseInfStatement(self): + if not self._IsKeyword("INF"): return None - ffsInf = FfsInfStatement.FfsInfStatement() - self.__GetInfOptions(ffsInf) + ffsInf = FfsInfStatement() + self._GetInfOptions(ffsInf) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected INF file path", self.FileName, self.CurrentLineNumber) - ffsInf.InfFileName = self.__Token + ffsInf.InfFileName = self._Token if not ffsInf.InfFileName.endswith('.inf'): raise Warning("expected .inf file path", self.FileName, self.CurrentLineNumber) ffsInf.CurrentLineNum = self.CurrentLineNumber - ffsInf.CurrentLineContent = self.__CurrentLine() + ffsInf.CurrentLineContent = self._CurrentLine() #Replace $(SAPCE) with real space ffsInf.InfFileName = ffsInf.InfFileName.replace('$(SPACE)', ' ') - if ffsInf.InfFileName.replace('$(WORKSPACE)', '').find('$') == -1: + if ffsInf.InfFileName.replace(TAB_WORKSPACE, '').find('$') == -1: #do case sensitive check for file path ErrorCode, ErrorInfo = PathClass(NormPath(ffsInf.InfFileName), GenFdsGlobalVariable.WorkSpaceDir).Validate() if ErrorCode != 0: @@ -2492,16 +2427,16 @@ class FdfParser: else: self.Profile.InfDict['ArchTBD'].append(ffsInf.InfFileName) - if self.__IsToken('|'): - if self.__IsKeyword('RELOCS_STRIPPED'): + if self._IsToken(TAB_VALUE_SPLIT): + if self._IsKeyword('RELOCS_STRIPPED'): ffsInf.KeepReloc = False - elif self.__IsKeyword('RELOCS_RETAINED'): + elif self._IsKeyword('RELOCS_RETAINED'): ffsInf.KeepReloc = True else: - raise Warning("Unknown reloc strip flag '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) + raise Warning("Unknown reloc strip flag '%s'" % self._Token, self.FileName, self.CurrentLineNumber) return ffsInf - ## __GetInfStatement() method + ## _GetInfStatement() method # # Get INF statements # @@ -2510,86 +2445,86 @@ class FdfParser: # @retval True Successfully find inf statement # @retval False Not able to find inf statement # - def __GetInfStatement(self, Obj, ForCapsule=False): - ffsInf = self.__ParseInfStatement() + def _GetInfStatement(self, Obj, ForCapsule=False): + ffsInf = self._ParseInfStatement() if not ffsInf: return False if ForCapsule: - capsuleFfs = CapsuleData.CapsuleFfs() - capsuleFfs.Ffs = ffsInf - Obj.CapsuleDataList.append(capsuleFfs) + myCapsuleFfs = CapsuleFfs() + myCapsuleFfs.Ffs = ffsInf + Obj.CapsuleDataList.append(myCapsuleFfs) else: Obj.FfsList.append(ffsInf) return True - ## __GetInfOptions() method + ## _GetInfOptions() method # # Get options for INF # # @param self The object pointer # @param FfsInfObj for whom option is got # - def __GetInfOptions(self, FfsInfObj): - if self.__IsKeyword("FILE_GUID"): - if not self.__IsToken("="): + def _GetInfOptions(self, FfsInfObj): + if self._IsKeyword("FILE_GUID"): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextGuid(): + if not self._GetNextGuid(): raise Warning("expected GUID value", self.FileName, self.CurrentLineNumber) - FfsInfObj.OverrideGuid = self.__Token + FfsInfObj.OverrideGuid = self._Token - if self.__IsKeyword( "RuleOverride"): - if not self.__IsToken( "="): + if self._IsKeyword("RuleOverride"): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected Rule name", self.FileName, self.CurrentLineNumber) - FfsInfObj.Rule = self.__Token + FfsInfObj.Rule = self._Token - if self.__IsKeyword( "VERSION"): - if not self.__IsToken( "="): + if self._IsKeyword("VERSION"): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected Version", self.FileName, self.CurrentLineNumber) - if self.__GetStringData(): - FfsInfObj.Version = self.__Token + if self._GetStringData(): + FfsInfObj.Version = self._Token - if self.__IsKeyword( BINARY_FILE_TYPE_UI): - if not self.__IsToken( "="): + if self._IsKeyword(BINARY_FILE_TYPE_UI): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected UI name", self.FileName, self.CurrentLineNumber) - if self.__GetStringData(): - FfsInfObj.Ui = self.__Token + if self._GetStringData(): + FfsInfObj.Ui = self._Token - if self.__IsKeyword( "USE"): - if not self.__IsToken( "="): + if self._IsKeyword("USE"): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected ARCH name", self.FileName, self.CurrentLineNumber) - FfsInfObj.UseArch = self.__Token + FfsInfObj.UseArch = self._Token - if self.__GetNextToken(): - p = re.compile(r'([a-zA-Z0-9\-]+|\$\(TARGET\)|\*)_([a-zA-Z0-9\-]+|\$\(TOOL_CHAIN_TAG\)|\*)_([a-zA-Z0-9\-]+|\$\(ARCH\))') - if p.match(self.__Token) and p.match(self.__Token).span()[1] == len(self.__Token): - FfsInfObj.KeyStringList.append(self.__Token) - if not self.__IsToken(","): + if self._GetNextToken(): + p = compile(r'([a-zA-Z0-9\-]+|\$\(TARGET\)|\*)_([a-zA-Z0-9\-]+|\$\(TOOL_CHAIN_TAG\)|\*)_([a-zA-Z0-9\-]+|\$\(ARCH\))') + if p.match(self._Token) and p.match(self._Token).span()[1] == len(self._Token): + FfsInfObj.KeyStringList.append(self._Token) + if not self._IsToken(TAB_COMMA_SPLIT): return else: - self.__UndoToken() + self._UndoToken() return - while self.__GetNextToken(): - if not p.match(self.__Token): + while self._GetNextToken(): + if not p.match(self._Token): raise Warning("expected KeyString \"Target_Tag_Arch\"", self.FileName, self.CurrentLineNumber) - FfsInfObj.KeyStringList.append(self.__Token) + FfsInfObj.KeyStringList.append(self._Token) - if not self.__IsToken(","): + if not self._IsToken(TAB_COMMA_SPLIT): break - ## __GetFileStatement() method + ## _GetFileStatement() method # # Get FILE statements # @@ -2599,42 +2534,41 @@ class FdfParser: # @retval True Successfully find FILE statement # @retval False Not able to find FILE statement # - def __GetFileStatement(self, Obj, ForCapsule = False, MacroDict = {}): - - if not self.__IsKeyword( "FILE"): + def _GetFileStatement(self, Obj, ForCapsule = False, MacroDict = {}): + if not self._IsKeyword("FILE"): return False - if not self.__GetNextWord(): + if not self._GetNextWord(): raise Warning("expected FFS type", self.FileName, self.CurrentLineNumber) - if ForCapsule and self.__Token == 'DATA': - self.__UndoToken() - self.__UndoToken() + if ForCapsule and self._Token == 'DATA': + self._UndoToken() + self._UndoToken() return False - FfsFileObj = FfsFileStatement.FileStatement() - FfsFileObj.FvFileType = self.__Token + FfsFileObj = FileStatement() + FfsFileObj.FvFileType = self._Token - if not self.__IsToken( "="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextGuid(): - if not self.__GetNextWord(): + if not self._GetNextGuid(): + if not self._GetNextWord(): raise Warning("expected File GUID", self.FileName, self.CurrentLineNumber) - if self.__Token == 'PCD': - if not self.__IsToken( "("): + if self._Token == 'PCD': + if not self._IsToken("("): raise Warning("expected '('", self.FileName, self.CurrentLineNumber) - PcdPair = self.__GetNextPcdSettings() - if not self.__IsToken( ")"): + PcdPair = self._GetNextPcdSettings() + if not self._IsToken(")"): raise Warning("expected ')'", self.FileName, self.CurrentLineNumber) - self.__Token = 'PCD('+PcdPair[1]+'.'+PcdPair[0]+')' + self._Token = 'PCD('+PcdPair[1]+TAB_SPLIT+PcdPair[0]+')' - FfsFileObj.NameGuid = self.__Token + FfsFileObj.NameGuid = self._Token - self.__GetFilePart( FfsFileObj, MacroDict.copy()) + self._GetFilePart(FfsFileObj, MacroDict.copy()) if ForCapsule: - capsuleFfs = CapsuleData.CapsuleFfs() + capsuleFfs = CapsuleFfs() capsuleFfs.Ffs = FfsFileObj Obj.CapsuleDataList.append(capsuleFfs) else: @@ -2642,7 +2576,7 @@ class FdfParser: return True - ## __FileCouldHaveRelocFlag() method + ## _FileCouldHaveRelocFlag() method # # Check whether reloc strip flag can be set for a file type. # @@ -2651,13 +2585,13 @@ class FdfParser: # @retval False No way to have it # @staticmethod - def __FileCouldHaveRelocFlag (FileType): + def _FileCouldHaveRelocFlag (FileType): if FileType in (SUP_MODULE_SEC, SUP_MODULE_PEI_CORE, SUP_MODULE_PEIM, 'PEI_DXE_COMBO'): return True else: return False - ## __SectionCouldHaveRelocFlag() method + ## _SectionCouldHaveRelocFlag() method # # Check whether reloc strip flag can be set for a section type. # @@ -2666,13 +2600,13 @@ class FdfParser: # @retval False No way to have it # @staticmethod - def __SectionCouldHaveRelocFlag (SectionType): + def _SectionCouldHaveRelocFlag (SectionType): if SectionType in (BINARY_FILE_TYPE_TE, BINARY_FILE_TYPE_PE32): return True else: return False - ## __GetFilePart() method + ## _GetFilePart() method # # Get components for FILE statement # @@ -2680,58 +2614,57 @@ class FdfParser: # @param FfsFileObj for whom component is got # @param MacroDict dictionary used to replace macro # - def __GetFilePart(self, FfsFileObj, MacroDict = {}): + def _GetFilePart(self, FfsFileObj, MacroDict = {}): + self._GetFileOpts(FfsFileObj) - self.__GetFileOpts( FfsFileObj) - - if not self.__IsToken("{"): - if self.__IsKeyword('RELOCS_STRIPPED') or self.__IsKeyword('RELOCS_RETAINED'): - if self.__FileCouldHaveRelocFlag(FfsFileObj.FvFileType): - if self.__Token == 'RELOCS_STRIPPED': + if not self._IsToken("{"): + if self._IsKeyword('RELOCS_STRIPPED') or self._IsKeyword('RELOCS_RETAINED'): + if self._FileCouldHaveRelocFlag(FfsFileObj.FvFileType): + if self._Token == 'RELOCS_STRIPPED': FfsFileObj.KeepReloc = False else: FfsFileObj.KeepReloc = True else: raise Warning("File type %s could not have reloc strip flag%d" % (FfsFileObj.FvFileType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber) - if not self.__IsToken("{"): + if not self._IsToken("{"): raise Warning("expected '{'", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected File name or section data", self.FileName, self.CurrentLineNumber) - if self.__Token == BINARY_FILE_TYPE_FV: - if not self.__IsToken( "="): + if self._Token == BINARY_FILE_TYPE_FV: + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected FV name", self.FileName, self.CurrentLineNumber) - FfsFileObj.FvName = self.__Token + FfsFileObj.FvName = self._Token - elif self.__Token == "FD": - if not self.__IsToken( "="): + elif self._Token == "FD": + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected FD name", self.FileName, self.CurrentLineNumber) - FfsFileObj.FdName = self.__Token + FfsFileObj.FdName = self._Token - elif self.__Token in ("DEFINE", "APRIORI", "SECTION"): - self.__UndoToken() - self.__GetSectionData( FfsFileObj, MacroDict) + elif self._Token in (TAB_DEFINE, "APRIORI", "SECTION"): + self._UndoToken() + self._GetSectionData(FfsFileObj, MacroDict) elif hasattr(FfsFileObj, 'FvFileType') and FfsFileObj.FvFileType == 'RAW': - self.__UndoToken() - self.__GetRAWData(FfsFileObj, MacroDict) + self._UndoToken() + self._GetRAWData(FfsFileObj, MacroDict) else: FfsFileObj.CurrentLineNum = self.CurrentLineNumber - FfsFileObj.CurrentLineContent = self.__CurrentLine() - FfsFileObj.FileName = self.__Token.replace('$(SPACE)', ' ') - self.__VerifyFile(FfsFileObj.FileName) + FfsFileObj.CurrentLineContent = self._CurrentLine() + FfsFileObj.FileName = self._Token.replace('$(SPACE)', ' ') + self._VerifyFile(FfsFileObj.FileName) - if not self.__IsToken( "}"): + if not self._IsToken("}"): raise Warning("expected '}'", self.FileName, self.CurrentLineNumber) - ## __GetRAWData() method + ## _GetRAWData() method # # Get RAW data for FILE statement # @@ -2739,33 +2672,32 @@ class FdfParser: # @param FfsFileObj for whom section is got # @param MacroDict dictionary used to replace macro # - def __GetRAWData(self, FfsFileObj, MacroDict = {}): + def _GetRAWData(self, FfsFileObj, MacroDict = {}): FfsFileObj.FileName = [] FfsFileObj.SubAlignment = [] while True: AlignValue = None - if self.__GetAlignment(): - if self.__Token not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K", "64K", "128K", - "256K", "512K", "1M", "2M", "4M", "8M", "16M"): - raise Warning("Incorrect alignment '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) + if self._GetAlignment(): + if self._Token not in ALIGNMENTS: + raise Warning("Incorrect alignment '%s'" % self._Token, self.FileName, self.CurrentLineNumber) #For FFS, Auto is default option same to "" - if not self.__Token == "Auto": - AlignValue = self.__Token - if not self.__GetNextToken(): + if not self._Token == "Auto": + AlignValue = self._Token + if not self._GetNextToken(): raise Warning("expected Filename value", self.FileName, self.CurrentLineNumber) - FileName = self.__Token.replace('$(SPACE)', ' ') + FileName = self._Token.replace('$(SPACE)', ' ') if FileName == '}': - self.__UndoToken() + self._UndoToken() raise Warning("expected Filename value", self.FileName, self.CurrentLineNumber) - self.__VerifyFile(FileName) + self._VerifyFile(FileName) File = PathClass(NormPath(FileName), GenFdsGlobalVariable.WorkSpaceDir) FfsFileObj.FileName.append(File.Path) FfsFileObj.SubAlignment.append(AlignValue) - if self.__IsToken( "}"): - self.__UndoToken() + if self._IsToken("}"): + self._UndoToken() break if len(FfsFileObj.SubAlignment) == 1: @@ -2773,45 +2705,43 @@ class FdfParser: if len(FfsFileObj.FileName) == 1: FfsFileObj.FileName = FfsFileObj.FileName[0] - ## __GetFileOpts() method + ## _GetFileOpts() method # # Get options for FILE statement # # @param self The object pointer # @param FfsFileObj for whom options is got # - def __GetFileOpts(self, FfsFileObj): - - if self.__GetNextToken(): - if TokenFindPattern.match(self.__Token): - FfsFileObj.KeyStringList.append(self.__Token) - if self.__IsToken(","): - while self.__GetNextToken(): - if not TokenFindPattern.match(self.__Token): + def _GetFileOpts(self, FfsFileObj): + if self._GetNextToken(): + if TokenFindPattern.match(self._Token): + FfsFileObj.KeyStringList.append(self._Token) + if self._IsToken(TAB_COMMA_SPLIT): + while self._GetNextToken(): + if not TokenFindPattern.match(self._Token): raise Warning("expected KeyString \"Target_Tag_Arch\"", self.FileName, self.CurrentLineNumber) - FfsFileObj.KeyStringList.append(self.__Token) + FfsFileObj.KeyStringList.append(self._Token) - if not self.__IsToken(","): + if not self._IsToken(TAB_COMMA_SPLIT): break else: - self.__UndoToken() + self._UndoToken() - if self.__IsKeyword( "FIXED", True): + if self._IsKeyword("FIXED", True): FfsFileObj.Fixed = True - if self.__IsKeyword( "CHECKSUM", True): + if self._IsKeyword("CHECKSUM", True): FfsFileObj.CheckSum = True - if self.__GetAlignment(): - if self.__Token not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K", "64K", "128K", - "256K", "512K", "1M", "2M", "4M", "8M", "16M"): - raise Warning("Incorrect alignment '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) + if self._GetAlignment(): + if self._Token not in ALIGNMENTS: + raise Warning("Incorrect alignment '%s'" % self._Token, self.FileName, self.CurrentLineNumber) #For FFS, Auto is default option same to "" - if not self.__Token == "Auto": - FfsFileObj.Alignment = self.__Token + if not self._Token == "Auto": + FfsFileObj.Alignment = self._Token - ## __GetAlignment() method + ## _GetAlignment() method # # Return the alignment value # @@ -2819,18 +2749,18 @@ class FdfParser: # @retval True Successfully find alignment # @retval False Not able to find alignment # - def __GetAlignment(self): - if self.__IsKeyword( "Align", True): - if not self.__IsToken( "="): + def _GetAlignment(self): + if self._IsKeyword("Align", True): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected alignment value", self.FileName, self.CurrentLineNumber) return True return False - ## __GetFilePart() method + ## _GetFilePart() method # # Get section data for FILE statement # @@ -2838,23 +2768,23 @@ class FdfParser: # @param FfsFileObj for whom section is got # @param MacroDict dictionary used to replace macro # - def __GetSectionData(self, FfsFileObj, MacroDict = {}): + def _GetSectionData(self, FfsFileObj, MacroDict = {}): Dict = {} Dict.update(MacroDict) - self.__GetDefineStatements(FfsFileObj) + self._GetDefineStatements(FfsFileObj) Dict.update(FfsFileObj.DefineVarDict) - self.__GetAprioriSection(FfsFileObj, Dict.copy()) - self.__GetAprioriSection(FfsFileObj, Dict.copy()) + self._GetAprioriSection(FfsFileObj, Dict.copy()) + self._GetAprioriSection(FfsFileObj, Dict.copy()) while True: - IsLeafSection = self.__GetLeafSection(FfsFileObj, Dict) - IsEncapSection = self.__GetEncapsulationSec(FfsFileObj) + IsLeafSection = self._GetLeafSection(FfsFileObj, Dict) + IsEncapSection = self._GetEncapsulationSec(FfsFileObj) if not IsLeafSection and not IsEncapSection: break - ## __GetLeafSection() method + ## _GetLeafSection() method # # Get leaf section for Obj # @@ -2864,97 +2794,95 @@ class FdfParser: # @retval True Successfully find section statement # @retval False Not able to find section statement # - def __GetLeafSection(self, Obj, MacroDict = {}): - + def _GetLeafSection(self, Obj, MacroDict = {}): OldPos = self.GetFileBufferPos() - if not self.__IsKeyword( "SECTION"): + if not self._IsKeyword("SECTION"): if len(Obj.SectionList) == 0: raise Warning("expected SECTION", self.FileName, self.CurrentLineNumber) else: return False AlignValue = None - if self.__GetAlignment(): - if self.__Token not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K", "64K", "128K", - "256K", "512K", "1M", "2M", "4M", "8M", "16M"): - raise Warning("Incorrect alignment '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) - AlignValue = self.__Token + if self._GetAlignment(): + if self._Token not in ALIGNMENTS: + raise Warning("Incorrect alignment '%s'" % self._Token, self.FileName, self.CurrentLineNumber) + AlignValue = self._Token BuildNum = None - if self.__IsKeyword( "BUILD_NUM"): - if not self.__IsToken( "="): + if self._IsKeyword("BUILD_NUM"): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected Build number value", self.FileName, self.CurrentLineNumber) - BuildNum = self.__Token + BuildNum = self._Token - if self.__IsKeyword( "VERSION"): + if self._IsKeyword("VERSION"): if AlignValue == 'Auto': raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber) - if not self.__IsToken( "="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected version", self.FileName, self.CurrentLineNumber) - VerSectionObj = VerSection.VerSection() + VerSectionObj = VerSection() VerSectionObj.Alignment = AlignValue VerSectionObj.BuildNum = BuildNum - if self.__GetStringData(): - VerSectionObj.StringData = self.__Token + if self._GetStringData(): + VerSectionObj.StringData = self._Token else: - VerSectionObj.FileName = self.__Token + VerSectionObj.FileName = self._Token Obj.SectionList.append(VerSectionObj) - elif self.__IsKeyword( BINARY_FILE_TYPE_UI): + elif self._IsKeyword(BINARY_FILE_TYPE_UI): if AlignValue == 'Auto': raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber) - if not self.__IsToken( "="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected UI", self.FileName, self.CurrentLineNumber) - UiSectionObj = UiSection.UiSection() + UiSectionObj = UiSection() UiSectionObj.Alignment = AlignValue - if self.__GetStringData(): - UiSectionObj.StringData = self.__Token + if self._GetStringData(): + UiSectionObj.StringData = self._Token else: - UiSectionObj.FileName = self.__Token + UiSectionObj.FileName = self._Token Obj.SectionList.append(UiSectionObj) - elif self.__IsKeyword( "FV_IMAGE"): + elif self._IsKeyword("FV_IMAGE"): if AlignValue == 'Auto': raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber) - if not self.__IsToken( "="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected FV name or FV file path", self.FileName, self.CurrentLineNumber) - FvName = self.__Token + FvName = self._Token FvObj = None - if self.__IsToken( "{"): - FvObj = Fv.FV() + if self._IsToken("{"): + FvObj = FV() FvObj.UiFvName = FvName.upper() - self.__GetDefineStatements(FvObj) + self._GetDefineStatements(FvObj) MacroDict.update(FvObj.DefineVarDict) - self.__GetBlockStatement(FvObj) - self.__GetSetStatements(FvObj) - self.__GetFvAlignment(FvObj) - self.__GetFvAttributes(FvObj) - self.__GetAprioriSection(FvObj, MacroDict.copy()) - self.__GetAprioriSection(FvObj, MacroDict.copy()) + self._GetBlockStatement(FvObj) + self._GetSetStatements(FvObj) + self._GetFvAlignment(FvObj) + self._GetFvAttributes(FvObj) + self._GetAprioriSection(FvObj, MacroDict.copy()) + self._GetAprioriSection(FvObj, MacroDict.copy()) while True: - IsInf = self.__GetInfStatement(FvObj) - IsFile = self.__GetFileStatement(FvObj, MacroDict.copy()) + IsInf = self._GetInfStatement(FvObj) + IsFile = self._GetFileStatement(FvObj, MacroDict.copy()) if not IsInf and not IsFile: break - if not self.__IsToken( "}"): + if not self._IsToken("}"): raise Warning("expected '}'", self.FileName, self.CurrentLineNumber) - FvImageSectionObj = FvImageSection.FvImageSection() + FvImageSectionObj = FvImageSection() FvImageSectionObj.Alignment = AlignValue if FvObj is not None: FvImageSectionObj.Fv = FvObj @@ -2965,81 +2893,81 @@ class FdfParser: Obj.SectionList.append(FvImageSectionObj) - elif self.__IsKeyword("PEI_DEPEX_EXP") or self.__IsKeyword("DXE_DEPEX_EXP") or self.__IsKeyword("SMM_DEPEX_EXP"): + elif self._IsKeyword("PEI_DEPEX_EXP") or self._IsKeyword("DXE_DEPEX_EXP") or self._IsKeyword("SMM_DEPEX_EXP"): if AlignValue == 'Auto': raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber) - DepexSectionObj = DepexSection.DepexSection() + DepexSectionObj = DepexSection() DepexSectionObj.Alignment = AlignValue - DepexSectionObj.DepexType = self.__Token + DepexSectionObj.DepexType = self._Token - if not self.__IsToken( "="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__IsToken( "{"): + if not self._IsToken("{"): raise Warning("expected '{'", self.FileName, self.CurrentLineNumber) - if not self.__SkipToToken( "}"): + if not self._SkipToToken("}"): raise Warning("expected Depex expression ending '}'", self.FileName, self.CurrentLineNumber) - DepexSectionObj.Expression = self.__SkippedChars.rstrip('}') + DepexSectionObj.Expression = self._SkippedChars.rstrip('}') Obj.SectionList.append(DepexSectionObj) else: - if not self.__GetNextWord(): + if not self._GetNextWord(): raise Warning("expected section type", self.FileName, self.CurrentLineNumber) # Encapsulation section appear, UndoToken and return - if self.__Token == "COMPRESS" or self.__Token == "GUIDED": + if self._Token == "COMPRESS" or self._Token == "GUIDED": self.SetFileBufferPos(OldPos) return False - if self.__Token not in ("COMPAT16", BINARY_FILE_TYPE_PE32, BINARY_FILE_TYPE_PIC, BINARY_FILE_TYPE_TE, "FV_IMAGE", "RAW", BINARY_FILE_TYPE_DXE_DEPEX,\ + if self._Token not in ("COMPAT16", BINARY_FILE_TYPE_PE32, BINARY_FILE_TYPE_PIC, BINARY_FILE_TYPE_TE, "FV_IMAGE", "RAW", BINARY_FILE_TYPE_DXE_DEPEX,\ BINARY_FILE_TYPE_UI, "VERSION", BINARY_FILE_TYPE_PEI_DEPEX, "SUBTYPE_GUID", BINARY_FILE_TYPE_SMM_DEPEX): - raise Warning("Unknown section type '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) - if AlignValue == 'Auto'and (not self.__Token == BINARY_FILE_TYPE_PE32) and (not self.__Token == BINARY_FILE_TYPE_TE): + raise Warning("Unknown section type '%s'" % self._Token, self.FileName, self.CurrentLineNumber) + if AlignValue == 'Auto'and (not self._Token == BINARY_FILE_TYPE_PE32) and (not self._Token == BINARY_FILE_TYPE_TE): raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber) # DataSection - DataSectionObj = DataSection.DataSection() + DataSectionObj = DataSection() DataSectionObj.Alignment = AlignValue - DataSectionObj.SecType = self.__Token + DataSectionObj.SecType = self._Token - if self.__IsKeyword('RELOCS_STRIPPED') or self.__IsKeyword('RELOCS_RETAINED'): - if self.__FileCouldHaveRelocFlag(Obj.FvFileType) and self.__SectionCouldHaveRelocFlag(DataSectionObj.SecType): - if self.__Token == 'RELOCS_STRIPPED': + if self._IsKeyword('RELOCS_STRIPPED') or self._IsKeyword('RELOCS_RETAINED'): + if self._FileCouldHaveRelocFlag(Obj.FvFileType) and self._SectionCouldHaveRelocFlag(DataSectionObj.SecType): + if self._Token == 'RELOCS_STRIPPED': DataSectionObj.KeepReloc = False else: DataSectionObj.KeepReloc = True else: raise Warning("File type %s, section type %s, could not have reloc strip flag%d" % (Obj.FvFileType, DataSectionObj.SecType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber) - if self.__IsToken("="): - if not self.__GetNextToken(): + if self._IsToken(TAB_EQUAL_SPLIT): + if not self._GetNextToken(): raise Warning("expected section file path", self.FileName, self.CurrentLineNumber) - DataSectionObj.SectFileName = self.__Token - self.__VerifyFile(DataSectionObj.SectFileName) + DataSectionObj.SectFileName = self._Token + self._VerifyFile(DataSectionObj.SectFileName) else: - if not self.__GetCglSection(DataSectionObj): + if not self._GetCglSection(DataSectionObj): return False Obj.SectionList.append(DataSectionObj) return True - ## __VerifyFile + ## _VerifyFile # # Check if file exists or not: # If current phase if GenFds, the file must exist; # If current phase is AutoGen and the file is not in $(OUTPUT_DIRECTORY), the file must exist # @param FileName: File path to be verified. # - def __VerifyFile(self, FileName): - if FileName.replace('$(WORKSPACE)', '').find('$') != -1: + def _VerifyFile(self, FileName): + if FileName.replace(TAB_WORKSPACE, '').find('$') != -1: return - if not GlobalData.gAutoGenPhase or not self.__GetMacroValue("OUTPUT_DIRECTORY") in FileName: + if not GlobalData.gAutoGenPhase or not self._GetMacroValue(TAB_DSC_DEFINES_OUTPUT_DIRECTORY) in FileName: ErrorCode, ErrorInfo = PathClass(NormPath(FileName), GenFdsGlobalVariable.WorkSpaceDir).Validate() if ErrorCode != 0: EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo) - ## __GetCglSection() method + ## _GetCglSection() method # # Get compressed or GUIDed section for Obj # @@ -3049,28 +2977,28 @@ class FdfParser: # @retval True Successfully find section statement # @retval False Not able to find section statement # - def __GetCglSection(self, Obj, AlignValue = None): + def _GetCglSection(self, Obj, AlignValue = None): - if self.__IsKeyword( "COMPRESS"): + if self._IsKeyword("COMPRESS"): type = "PI_STD" - if self.__IsKeyword("PI_STD") or self.__IsKeyword("PI_NONE"): - type = self.__Token + if self._IsKeyword("PI_STD") or self._IsKeyword("PI_NONE"): + type = self._Token - if not self.__IsToken("{"): + if not self._IsToken("{"): raise Warning("expected '{'", self.FileName, self.CurrentLineNumber) - CompressSectionObj = CompressSection.CompressSection() + CompressSectionObj = CompressSection() CompressSectionObj.Alignment = AlignValue CompressSectionObj.CompType = type # Recursive sections... while True: - IsLeafSection = self.__GetLeafSection(CompressSectionObj) - IsEncapSection = self.__GetEncapsulationSec(CompressSectionObj) + IsLeafSection = self._GetLeafSection(CompressSectionObj) + IsEncapSection = self._GetEncapsulationSec(CompressSectionObj) if not IsLeafSection and not IsEncapSection: break - if not self.__IsToken( "}"): + if not self._IsToken("}"): raise Warning("expected '}'", self.FileName, self.CurrentLineNumber) Obj.SectionList.append(CompressSectionObj) @@ -3079,15 +3007,15 @@ class FdfParser: return True - elif self.__IsKeyword( "GUIDED"): + elif self._IsKeyword("GUIDED"): GuidValue = None - if self.__GetNextGuid(): - GuidValue = self.__Token + if self._GetNextGuid(): + GuidValue = self._Token - AttribDict = self.__GetGuidAttrib() - if not self.__IsToken("{"): + AttribDict = self._GetGuidAttrib() + if not self._IsToken("{"): raise Warning("expected '{'", self.FileName, self.CurrentLineNumber) - GuidSectionObj = GuidSection.GuidSection() + GuidSectionObj = GuidSection() GuidSectionObj.Alignment = AlignValue GuidSectionObj.NameGuid = GuidValue GuidSectionObj.SectionType = "GUIDED" @@ -3096,12 +3024,12 @@ class FdfParser: GuidSectionObj.ExtraHeaderSize = AttribDict["EXTRA_HEADER_SIZE"] # Recursive sections... while True: - IsLeafSection = self.__GetLeafSection(GuidSectionObj) - IsEncapSection = self.__GetEncapsulationSec(GuidSectionObj) + IsLeafSection = self._GetLeafSection(GuidSectionObj) + IsEncapSection = self._GetEncapsulationSec(GuidSectionObj) if not IsLeafSection and not IsEncapSection: break - if not self.__IsToken( "}"): + if not self._IsToken("}"): raise Warning("expected '}'", self.FileName, self.CurrentLineNumber) Obj.SectionList.append(GuidSectionObj) @@ -3109,44 +3037,43 @@ class FdfParser: return False - ## __GetGuidAttri() method + ## _GetGuidAttri() method # # Get attributes for GUID section # # @param self The object pointer # @retval AttribDict Dictionary of key-value pair of section attributes # - def __GetGuidAttrib(self): - + def _GetGuidAttrib(self): AttribDict = {} AttribDict["PROCESSING_REQUIRED"] = "NONE" AttribDict["AUTH_STATUS_VALID"] = "NONE" AttribDict["EXTRA_HEADER_SIZE"] = -1 - while self.__IsKeyword("PROCESSING_REQUIRED") or self.__IsKeyword("AUTH_STATUS_VALID") \ - or self.__IsKeyword("EXTRA_HEADER_SIZE"): - AttribKey = self.__Token + while self._IsKeyword("PROCESSING_REQUIRED") or self._IsKeyword("AUTH_STATUS_VALID") \ + or self._IsKeyword("EXTRA_HEADER_SIZE"): + AttribKey = self._Token - if not self.__IsToken("="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected TRUE(1)/FALSE(0)/Number", self.FileName, self.CurrentLineNumber) elif AttribKey == "EXTRA_HEADER_SIZE": Base = 10 - if self.__Token[0:2].upper() == "0X": + if self._Token[0:2].upper() == "0X": Base = 16 try: - AttribDict[AttribKey] = int(self.__Token, Base) + AttribDict[AttribKey] = int(self._Token, Base) continue except ValueError: raise Warning("expected Number", self.FileName, self.CurrentLineNumber) - elif self.__Token.upper() not in ("TRUE", "FALSE", "1", "0"): + elif self._Token.upper() not in ("TRUE", "FALSE", "1", "0"): raise Warning("expected TRUE/FALSE (1/0)", self.FileName, self.CurrentLineNumber) - AttribDict[AttribKey] = self.__Token + AttribDict[AttribKey] = self._Token return AttribDict - ## __GetEncapsulationSec() method + ## _GetEncapsulationSec() method # # Get encapsulation section for FILE # @@ -3155,91 +3082,89 @@ class FdfParser: # @retval True Successfully find section statement # @retval False Not able to find section statement # - def __GetEncapsulationSec(self, FfsFileObj): - + def _GetEncapsulationSec(self, FfsFileObj): OldPos = self.GetFileBufferPos() - if not self.__IsKeyword( "SECTION"): + if not self._IsKeyword("SECTION"): if len(FfsFileObj.SectionList) == 0: raise Warning("expected SECTION", self.FileName, self.CurrentLineNumber) else: return False AlignValue = None - if self.__GetAlignment(): - if self.__Token not in ("8", "16", "32", "64", "128", "512", "1K", "4K", "32K", "64K", "128K", - "256K", "512K", "1M", "2M", "4M", "8M", "16M"): - raise Warning("Incorrect alignment '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) - AlignValue = self.__Token + if self._GetAlignment(): + if self._Token not in ALIGNMENT_NOAUTO: + raise Warning("Incorrect alignment '%s'" % self._Token, self.FileName, self.CurrentLineNumber) + AlignValue = self._Token - if not self.__GetCglSection(FfsFileObj, AlignValue): + if not self._GetCglSection(FfsFileObj, AlignValue): self.SetFileBufferPos(OldPos) return False else: return True - def __GetFmp(self): - if not self.__GetNextToken(): + def _GetFmp(self): + if not self._GetNextToken(): return False - S = self.__Token.upper() - if S.startswith("[") and not S.startswith("[FMPPAYLOAD."): + S = self._Token.upper() + if S.startswith(TAB_SECTION_START) and not S.startswith("[FMPPAYLOAD."): self.SectionParser(S) - self.__UndoToken() + self._UndoToken() return False - self.__UndoToken() - self.__SkipToToken("[FMPPAYLOAD.", True) - FmpUiName = self.__GetUiName().upper() + self._UndoToken() + self._SkipToToken("[FMPPAYLOAD.", True) + FmpUiName = self._GetUiName().upper() if FmpUiName in self.Profile.FmpPayloadDict: raise Warning("Duplicated FMP UI name found: %s" % FmpUiName, self.FileName, self.CurrentLineNumber) - FmpData = CapsuleData.CapsulePayload() + FmpData = CapsulePayload() FmpData.UiName = FmpUiName - if not self.__IsToken( "]"): + if not self._IsToken(TAB_SECTION_END): raise Warning("expected ']'", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("The FMP payload section is empty!", self.FileName, self.CurrentLineNumber) FmpKeyList = ['IMAGE_HEADER_INIT_VERSION', 'IMAGE_TYPE_ID', 'IMAGE_INDEX', 'HARDWARE_INSTANCE', 'CERTIFICATE_GUID', 'MONOTONIC_COUNT'] - while self.__Token in FmpKeyList: - Name = self.__Token + while self._Token in FmpKeyList: + Name = self._Token FmpKeyList.remove(Name) - if not self.__IsToken("="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) if Name == 'IMAGE_TYPE_ID': - if not self.__GetNextGuid(): + if not self._GetNextGuid(): raise Warning("expected GUID value for IMAGE_TYPE_ID.", self.FileName, self.CurrentLineNumber) - FmpData.ImageTypeId = self.__Token + FmpData.ImageTypeId = self._Token elif Name == 'CERTIFICATE_GUID': - if not self.__GetNextGuid(): + if not self._GetNextGuid(): raise Warning("expected GUID value for CERTIFICATE_GUID.", self.FileName, self.CurrentLineNumber) - FmpData.Certificate_Guid = self.__Token - if uuid.UUID(FmpData.Certificate_Guid) != EFI_CERT_TYPE_RSA2048_SHA256_GUID and uuid.UUID(FmpData.Certificate_Guid) != EFI_CERT_TYPE_PKCS7_GUID: + FmpData.Certificate_Guid = self._Token + if UUID(FmpData.Certificate_Guid) != EFI_CERT_TYPE_RSA2048_SHA256_GUID and UUID(FmpData.Certificate_Guid) != EFI_CERT_TYPE_PKCS7_GUID: raise Warning("Only support EFI_CERT_TYPE_RSA2048_SHA256_GUID or EFI_CERT_TYPE_PKCS7_GUID for CERTIFICATE_GUID.", self.FileName, self.CurrentLineNumber) else: - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected value of %s" % Name, self.FileName, self.CurrentLineNumber) - Value = self.__Token + Value = self._Token if Name == 'IMAGE_HEADER_INIT_VERSION': - if FdfParser.__Verify(Name, Value, 'UINT8'): + if FdfParser._Verify(Name, Value, 'UINT8'): FmpData.Version = Value elif Name == 'IMAGE_INDEX': - if FdfParser.__Verify(Name, Value, 'UINT8'): + if FdfParser._Verify(Name, Value, 'UINT8'): FmpData.ImageIndex = Value elif Name == 'HARDWARE_INSTANCE': - if FdfParser.__Verify(Name, Value, 'UINT8'): + if FdfParser._Verify(Name, Value, 'UINT8'): FmpData.HardwareInstance = Value elif Name == 'MONOTONIC_COUNT': - if FdfParser.__Verify(Name, Value, 'UINT64'): + if FdfParser._Verify(Name, Value, 'UINT64'): FmpData.MonotonicCount = Value if FmpData.MonotonicCount.upper().startswith('0X'): FmpData.MonotonicCount = (long)(FmpData.MonotonicCount, 16) else: FmpData.MonotonicCount = (long)(FmpData.MonotonicCount) - if not self.__GetNextToken(): + if not self._GetNextToken(): break else: - self.__UndoToken() + self._UndoToken() if (FmpData.MonotonicCount and not FmpData.Certificate_Guid) or (not FmpData.MonotonicCount and FmpData.Certificate_Guid): EdkLogger.error("FdfParser", FORMAT_INVALID, "CERTIFICATE_GUID and MONOTONIC_COUNT must be work as a pair.") @@ -3248,7 +3173,7 @@ class FdfParser: if FmpKeyList and 'IMAGE_TYPE_ID' in FmpKeyList: raise Warning("Missing keywords IMAGE_TYPE_ID in FMP payload section.", self.FileName, self.CurrentLineNumber) # get the Image file and Vendor code file - self.__GetFMPCapsuleData(FmpData) + self._GetFMPCapsuleData(FmpData) if not FmpData.ImageFile: raise Warning("Missing image file in FMP payload section.", self.FileName, self.CurrentLineNumber) # check whether more than one Vendor code file @@ -3257,7 +3182,7 @@ class FdfParser: self.Profile.FmpPayloadDict[FmpUiName] = FmpData return True - ## __GetCapsule() method + ## _GetCapsule() method # # Get capsule section contents and store its data into capsule list of self.Profile # @@ -3265,90 +3190,89 @@ class FdfParser: # @retval True Successfully find a capsule # @retval False Not able to find a capsule # - def __GetCapsule(self): - - if not self.__GetNextToken(): + def _GetCapsule(self): + if not self._GetNextToken(): return False - S = self.__Token.upper() - if S.startswith("[") and not S.startswith("[CAPSULE."): + S = self._Token.upper() + if S.startswith(TAB_SECTION_START) and not S.startswith("[CAPSULE."): self.SectionParser(S) - self.__UndoToken() + self._UndoToken() return False - self.__UndoToken() - if not self.__IsToken("[CAPSULE.", True): + self._UndoToken() + if not self._IsToken("[CAPSULE.", True): FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber) #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \ - # % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine) + # % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine:], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine) raise Warning("expected [Capsule.]", self.FileName, self.CurrentLineNumber) - CapsuleObj = Capsule.Capsule() + CapsuleObj = Capsule() - CapsuleName = self.__GetUiName() + CapsuleName = self._GetUiName() if not CapsuleName: raise Warning("expected capsule name", self.FileName, self.CurrentLineNumber) CapsuleObj.UiCapsuleName = CapsuleName.upper() - if not self.__IsToken( "]"): + if not self._IsToken(TAB_SECTION_END): raise Warning("expected ']'", self.FileName, self.CurrentLineNumber) - if self.__IsKeyword("CREATE_FILE"): - if not self.__IsToken( "="): + if self._IsKeyword("CREATE_FILE"): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected file name", self.FileName, self.CurrentLineNumber) - CapsuleObj.CreateFile = self.__Token + CapsuleObj.CreateFile = self._Token - self.__GetCapsuleStatements(CapsuleObj) + self._GetCapsuleStatements(CapsuleObj) self.Profile.CapsuleDict[CapsuleObj.UiCapsuleName] = CapsuleObj return True - ## __GetCapsuleStatements() method + ## _GetCapsuleStatements() method # # Get statements for capsule # # @param self The object pointer # @param Obj for whom statements are got # - def __GetCapsuleStatements(self, Obj): - self.__GetCapsuleTokens(Obj) - self.__GetDefineStatements(Obj) - self.__GetSetStatements(Obj) - self.__GetCapsuleData(Obj) + def _GetCapsuleStatements(self, Obj): + self._GetCapsuleTokens(Obj) + self._GetDefineStatements(Obj) + self._GetSetStatements(Obj) + self._GetCapsuleData(Obj) - ## __GetCapsuleTokens() method + ## _GetCapsuleTokens() method # # Get token statements for capsule # # @param self The object pointer # @param Obj for whom token statements are got # - def __GetCapsuleTokens(self, Obj): - if not self.__GetNextToken(): + def _GetCapsuleTokens(self, Obj): + if not self._GetNextToken(): return False - while self.__Token in ("CAPSULE_GUID", "CAPSULE_HEADER_SIZE", "CAPSULE_FLAGS", "OEM_CAPSULE_FLAGS", "CAPSULE_HEADER_INIT_VERSION"): - Name = self.__Token.strip() - if not self.__IsToken("="): + while self._Token in ("CAPSULE_GUID", "CAPSULE_HEADER_SIZE", "CAPSULE_FLAGS", "OEM_CAPSULE_FLAGS", "CAPSULE_HEADER_INIT_VERSION"): + Name = self._Token.strip() + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected value", self.FileName, self.CurrentLineNumber) if Name == 'CAPSULE_FLAGS': - if not self.__Token in ("PersistAcrossReset", "PopulateSystemTable", "InitiateReset"): + if not self._Token in ("PersistAcrossReset", "PopulateSystemTable", "InitiateReset"): raise Warning("expected PersistAcrossReset, PopulateSystemTable, or InitiateReset", self.FileName, self.CurrentLineNumber) - Value = self.__Token.strip() - while self.__IsToken(","): - Value += ',' - if not self.__GetNextToken(): + Value = self._Token.strip() + while self._IsToken(TAB_COMMA_SPLIT): + Value += TAB_COMMA_SPLIT + if not self._GetNextToken(): raise Warning("expected value", self.FileName, self.CurrentLineNumber) - if not self.__Token in ("PersistAcrossReset", "PopulateSystemTable", "InitiateReset"): + if not self._Token in ("PersistAcrossReset", "PopulateSystemTable", "InitiateReset"): raise Warning("expected PersistAcrossReset, PopulateSystemTable, or InitiateReset", self.FileName, self.CurrentLineNumber) - Value += self.__Token.strip() + Value += self._Token.strip() elif Name == 'OEM_CAPSULE_FLAGS': - Value = self.__Token.strip() + Value = self._Token.strip() if not Value.upper().startswith('0X'): raise Warning("expected hex value between 0x0000 and 0xFFFF", self.FileName, self.CurrentLineNumber) try: @@ -3357,51 +3281,49 @@ class FdfParser: raise Warning("expected hex value between 0x0000 and 0xFFFF", self.FileName, self.CurrentLineNumber) if not 0x0000 <= Value <= 0xFFFF: raise Warning("expected hex value between 0x0000 and 0xFFFF", self.FileName, self.CurrentLineNumber) - Value = self.__Token.strip() + Value = self._Token.strip() else: - Value = self.__Token.strip() + Value = self._Token.strip() Obj.TokensDict[Name] = Value - if not self.__GetNextToken(): + if not self._GetNextToken(): return False - self.__UndoToken() + self._UndoToken() - ## __GetCapsuleData() method + ## _GetCapsuleData() method # # Get capsule data for capsule # # @param self The object pointer # @param Obj for whom capsule data are got # - def __GetCapsuleData(self, Obj): - + def _GetCapsuleData(self, Obj): while True: - IsInf = self.__GetInfStatement(Obj, True) - IsFile = self.__GetFileStatement(Obj, True) - IsFv = self.__GetFvStatement(Obj) - IsFd = self.__GetFdStatement(Obj) - IsAnyFile = self.__GetAnyFileStatement(Obj) - IsAfile = self.__GetAfileStatement(Obj) - IsFmp = self.__GetFmpStatement(Obj) + IsInf = self._GetInfStatement(Obj, True) + IsFile = self._GetFileStatement(Obj, True) + IsFv = self._GetFvStatement(Obj) + IsFd = self._GetFdStatement(Obj) + IsAnyFile = self._GetAnyFileStatement(Obj) + IsAfile = self._GetAfileStatement(Obj) + IsFmp = self._GetFmpStatement(Obj) if not (IsInf or IsFile or IsFv or IsFd or IsAnyFile or IsAfile or IsFmp): break - ## __GetFMPCapsuleData() method + ## _GetFMPCapsuleData() method # # Get capsule data for FMP capsule # # @param self The object pointer # @param Obj for whom capsule data are got # - def __GetFMPCapsuleData(self, Obj): - + def _GetFMPCapsuleData(self, Obj): while True: - IsFv = self.__GetFvStatement(Obj, True) - IsFd = self.__GetFdStatement(Obj, True) - IsAnyFile = self.__GetAnyFileStatement(Obj, True) + IsFv = self._GetFvStatement(Obj, True) + IsFd = self._GetFdStatement(Obj, True) + IsAnyFile = self._GetAnyFileStatement(Obj, True) if not (IsFv or IsFd or IsAnyFile): break - ## __GetFvStatement() method + ## _GetFvStatement() method # # Get FV for capsule # @@ -3410,32 +3332,31 @@ class FdfParser: # @retval True Successfully find a FV statement # @retval False Not able to find a FV statement # - def __GetFvStatement(self, CapsuleObj, FMPCapsule = False): - - if not self.__IsKeyword(BINARY_FILE_TYPE_FV): + def _GetFvStatement(self, CapsuleObj, FMPCapsule = False): + if not self._IsKeyword(BINARY_FILE_TYPE_FV): return False - if not self.__IsToken("="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected FV name", self.FileName, self.CurrentLineNumber) - if self.__Token.upper() not in self.Profile.FvDict: + if self._Token.upper() not in self.Profile.FvDict: raise Warning("FV name does not exist", self.FileName, self.CurrentLineNumber) - CapsuleFv = CapsuleData.CapsuleFv() - CapsuleFv.FvName = self.__Token + myCapsuleFv = CapsuleFv() + myCapsuleFv.FvName = self._Token if FMPCapsule: if not CapsuleObj.ImageFile: - CapsuleObj.ImageFile.append(CapsuleFv) + CapsuleObj.ImageFile.append(myCapsuleFv) else: - CapsuleObj.VendorCodeFile.append(CapsuleFv) + CapsuleObj.VendorCodeFile.append(myCapsuleFv) else: - CapsuleObj.CapsuleDataList.append(CapsuleFv) + CapsuleObj.CapsuleDataList.append(myCapsuleFv) return True - ## __GetFdStatement() method + ## _GetFdStatement() method # # Get FD for capsule # @@ -3444,74 +3365,73 @@ class FdfParser: # @retval True Successfully find a FD statement # @retval False Not able to find a FD statement # - def __GetFdStatement(self, CapsuleObj, FMPCapsule = False): - - if not self.__IsKeyword("FD"): + def _GetFdStatement(self, CapsuleObj, FMPCapsule = False): + if not self._IsKeyword("FD"): return False - if not self.__IsToken("="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected FD name", self.FileName, self.CurrentLineNumber) - if self.__Token.upper() not in self.Profile.FdDict: + if self._Token.upper() not in self.Profile.FdDict: raise Warning("FD name does not exist", self.FileName, self.CurrentLineNumber) - CapsuleFd = CapsuleData.CapsuleFd() - CapsuleFd.FdName = self.__Token + myCapsuleFd = CapsuleFd() + myCapsuleFd.FdName = self._Token if FMPCapsule: if not CapsuleObj.ImageFile: - CapsuleObj.ImageFile.append(CapsuleFd) + CapsuleObj.ImageFile.append(myCapsuleFd) else: - CapsuleObj.VendorCodeFile.append(CapsuleFd) + CapsuleObj.VendorCodeFile.append(myCapsuleFd) else: - CapsuleObj.CapsuleDataList.append(CapsuleFd) + CapsuleObj.CapsuleDataList.append(myCapsuleFd) return True - def __GetFmpStatement(self, CapsuleObj): - if not self.__IsKeyword("FMP_PAYLOAD"): - if not self.__IsKeyword("FMP"): + def _GetFmpStatement(self, CapsuleObj): + if not self._IsKeyword("FMP_PAYLOAD"): + if not self._IsKeyword("FMP"): return False - if not self.__IsKeyword("PAYLOAD"): - self.__UndoToken() + if not self._IsKeyword("PAYLOAD"): + self._UndoToken() return False - if not self.__IsToken("="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected payload name after FMP_PAYLOAD =", self.FileName, self.CurrentLineNumber) - Payload = self.__Token.upper() + Payload = self._Token.upper() if Payload not in self.Profile.FmpPayloadDict: - raise Warning("This FMP Payload does not exist: %s" % self.__Token, self.FileName, self.CurrentLineNumber) + raise Warning("This FMP Payload does not exist: %s" % self._Token, self.FileName, self.CurrentLineNumber) CapsuleObj.FmpPayloadList.append(self.Profile.FmpPayloadDict[Payload]) return True - def __ParseRawFileStatement(self): - if not self.__IsKeyword("FILE"): + def _ParseRawFileStatement(self): + if not self._IsKeyword("FILE"): return None - if not self.__IsKeyword("DATA"): - self.__UndoToken() + if not self._IsKeyword("DATA"): + self._UndoToken() return None - if not self.__IsToken("="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected File name", self.FileName, self.CurrentLineNumber) - AnyFileName = self.__Token - self.__VerifyFile(AnyFileName) + AnyFileName = self._Token + self._VerifyFile(AnyFileName) if not os.path.isabs(AnyFileName): AnyFileName = mws.join(GenFdsGlobalVariable.WorkSpaceDir, AnyFileName) return AnyFileName - ## __GetAnyFileStatement() method + ## _GetAnyFileStatement() method # # Get AnyFile for capsule # @@ -3520,23 +3440,23 @@ class FdfParser: # @retval True Successfully find a Anyfile statement # @retval False Not able to find a AnyFile statement # - def __GetAnyFileStatement(self, CapsuleObj, FMPCapsule = False): - AnyFileName = self.__ParseRawFileStatement() + def _GetAnyFileStatement(self, CapsuleObj, FMPCapsule = False): + AnyFileName = self._ParseRawFileStatement() if not AnyFileName: return False - CapsuleAnyFile = CapsuleData.CapsuleAnyFile() - CapsuleAnyFile.FileName = AnyFileName + myCapsuleAnyFile = CapsuleAnyFile() + myCapsuleAnyFile.FileName = AnyFileName if FMPCapsule: if not CapsuleObj.ImageFile: - CapsuleObj.ImageFile.append(CapsuleAnyFile) + CapsuleObj.ImageFile.append(myCapsuleAnyFile) else: - CapsuleObj.VendorCodeFile.append(CapsuleAnyFile) + CapsuleObj.VendorCodeFile.append(myCapsuleAnyFile) else: - CapsuleObj.CapsuleDataList.append(CapsuleAnyFile) + CapsuleObj.CapsuleDataList.append(myCapsuleAnyFile) return True - ## __GetAfileStatement() method + ## _GetAfileStatement() method # # Get Afile for capsule # @@ -3545,18 +3465,17 @@ class FdfParser: # @retval True Successfully find a Afile statement # @retval False Not able to find a Afile statement # - def __GetAfileStatement(self, CapsuleObj): - - if not self.__IsKeyword("APPEND"): + def _GetAfileStatement(self, CapsuleObj): + if not self._IsKeyword("APPEND"): return False - if not self.__IsToken("="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected Afile name", self.FileName, self.CurrentLineNumber) - AfileName = self.__Token + AfileName = self._Token AfileBaseName = os.path.basename(AfileName) if os.path.splitext(AfileBaseName)[1] not in [".bin", ".BIN", ".Bin", ".dat", ".DAT", ".Dat", ".data", ".DATA", ".Data"]: @@ -3565,19 +3484,19 @@ class FdfParser: if not os.path.isabs(AfileName): AfileName = GenFdsGlobalVariable.ReplaceWorkspaceMacro(AfileName) - self.__VerifyFile(AfileName) + self._VerifyFile(AfileName) else: if not os.path.exists(AfileName): raise Warning('%s does not exist' % AfileName, self.FileName, self.CurrentLineNumber) else: pass - CapsuleAfile = CapsuleData.CapsuleAfile() - CapsuleAfile.FileName = AfileName - CapsuleObj.CapsuleDataList.append(CapsuleAfile) + myCapsuleAfile = CapsuleAfile() + myCapsuleAfile.FileName = AfileName + CapsuleObj.CapsuleDataList.append(myCapsuleAfile) return True - ## __GetRule() method + ## _GetRule() method # # Get Rule section contents and store its data into rule list of self.Profile # @@ -3585,143 +3504,140 @@ class FdfParser: # @retval True Successfully find a Rule # @retval False Not able to find a Rule # - def __GetRule(self): - - if not self.__GetNextToken(): + def _GetRule(self): + if not self._GetNextToken(): return False - S = self.__Token.upper() - if S.startswith("[") and not S.startswith("[RULE."): + S = self._Token.upper() + if S.startswith(TAB_SECTION_START) and not S.startswith("[RULE."): self.SectionParser(S) - self.__UndoToken() + self._UndoToken() return False - self.__UndoToken() - if not self.__IsToken("[Rule.", True): + self._UndoToken() + if not self._IsToken("[Rule.", True): FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber) #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \ - # % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine) + # % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine:], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine) raise Warning("expected [Rule.]", self.FileName, self.CurrentLineNumber) - if not self.__SkipToToken("."): + if not self._SkipToToken(TAB_SPLIT): raise Warning("expected '.'", self.FileName, self.CurrentLineNumber) - Arch = self.__SkippedChars.rstrip(".") + Arch = self._SkippedChars.rstrip(TAB_SPLIT) if Arch.upper() not in ARCH_SET_FULL: raise Warning("Unknown Arch '%s'" % Arch, self.FileName, self.CurrentLineNumber) - ModuleType = self.__GetModuleType() + ModuleType = self._GetModuleType() TemplateName = "" - if self.__IsToken("."): - if not self.__GetNextWord(): + if self._IsToken(TAB_SPLIT): + if not self._GetNextWord(): raise Warning("expected template name", self.FileName, self.CurrentLineNumber) - TemplateName = self.__Token + TemplateName = self._Token - if not self.__IsToken( "]"): + if not self._IsToken(TAB_SECTION_END): raise Warning("expected ']'", self.FileName, self.CurrentLineNumber) - RuleObj = self.__GetRuleFileStatements() + RuleObj = self._GetRuleFileStatements() RuleObj.Arch = Arch.upper() RuleObj.ModuleType = ModuleType RuleObj.TemplateName = TemplateName - if TemplateName == '' : + if TemplateName == '': self.Profile.RuleDict['RULE' + \ - '.' + \ + TAB_SPLIT + \ Arch.upper() + \ - '.' + \ + TAB_SPLIT + \ ModuleType.upper() ] = RuleObj - else : + else: self.Profile.RuleDict['RULE' + \ - '.' + \ + TAB_SPLIT + \ Arch.upper() + \ - '.' + \ + TAB_SPLIT + \ ModuleType.upper() + \ - '.' + \ + TAB_SPLIT + \ TemplateName.upper() ] = RuleObj return True - ## __GetModuleType() method + ## _GetModuleType() method # # Return the module type # # @param self The object pointer # @retval string module type # - def __GetModuleType(self): - - if not self.__GetNextWord(): + def _GetModuleType(self): + if not self._GetNextWord(): raise Warning("expected Module type", self.FileName, self.CurrentLineNumber) - if self.__Token.upper() not in (SUP_MODULE_SEC, SUP_MODULE_PEI_CORE, SUP_MODULE_PEIM, SUP_MODULE_DXE_CORE, \ + if self._Token.upper() not in (SUP_MODULE_SEC, SUP_MODULE_PEI_CORE, SUP_MODULE_PEIM, SUP_MODULE_DXE_CORE, \ SUP_MODULE_DXE_DRIVER, SUP_MODULE_DXE_SAL_DRIVER, \ SUP_MODULE_DXE_SMM_DRIVER, SUP_MODULE_DXE_RUNTIME_DRIVER, \ - SUP_MODULE_UEFI_DRIVER, SUP_MODULE_UEFI_APPLICATION, SUP_MODULE_USER_DEFINED, "DEFAULT", SUP_MODULE_BASE, \ + SUP_MODULE_UEFI_DRIVER, SUP_MODULE_UEFI_APPLICATION, SUP_MODULE_USER_DEFINED, TAB_DEFAULT, SUP_MODULE_BASE, \ EDK_COMPONENT_TYPE_SECURITY_CORE, EDK_COMPONENT_TYPE_COMBINED_PEIM_DRIVER, EDK_COMPONENT_TYPE_PIC_PEIM, EDK_COMPONENT_TYPE_RELOCATABLE_PEIM, \ "PE32_PEIM", EDK_COMPONENT_TYPE_BS_DRIVER, EDK_COMPONENT_TYPE_RT_DRIVER, EDK_COMPONENT_TYPE_SAL_RT_DRIVER, EDK_COMPONENT_TYPE_APPLICATION, "ACPITABLE", SUP_MODULE_SMM_CORE, SUP_MODULE_MM_STANDALONE, SUP_MODULE_MM_CORE_STANDALONE): - raise Warning("Unknown Module type '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) - return self.__Token + raise Warning("Unknown Module type '%s'" % self._Token, self.FileName, self.CurrentLineNumber) + return self._Token - ## __GetFileExtension() method + ## _GetFileExtension() method # # Return the file extension # # @param self The object pointer # @retval string file name extension # - def __GetFileExtension(self): - if not self.__IsToken("."): + def _GetFileExtension(self): + if not self._IsToken(TAB_SPLIT): raise Warning("expected '.'", self.FileName, self.CurrentLineNumber) Ext = "" - if self.__GetNextToken(): - if FileExtensionPattern.match(self.__Token): - Ext = self.__Token - return '.' + Ext + if self._GetNextToken(): + if FileExtensionPattern.match(self._Token): + Ext = self._Token + return TAB_SPLIT + Ext else: - raise Warning("Unknown file extension '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) + raise Warning("Unknown file extension '%s'" % self._Token, self.FileName, self.CurrentLineNumber) else: raise Warning("expected file extension", self.FileName, self.CurrentLineNumber) - ## __GetRuleFileStatement() method + ## _GetRuleFileStatement() method # # Get rule contents # # @param self The object pointer # @retval Rule Rule object # - def __GetRuleFileStatements(self): - - if not self.__IsKeyword("FILE"): + def _GetRuleFileStatements(self): + if not self._IsKeyword("FILE"): raise Warning("expected FILE", self.FileName, self.CurrentLineNumber) - if not self.__GetNextWord(): + if not self._GetNextWord(): raise Warning("expected FFS type", self.FileName, self.CurrentLineNumber) - Type = self.__Token.strip().upper() + Type = self._Token.strip().upper() if Type not in ("RAW", "FREEFORM", SUP_MODULE_SEC, SUP_MODULE_PEI_CORE, SUP_MODULE_PEIM,\ "PEI_DXE_COMBO", "DRIVER", SUP_MODULE_DXE_CORE, EDK_COMPONENT_TYPE_APPLICATION, "FV_IMAGE", "SMM", SUP_MODULE_SMM_CORE, SUP_MODULE_MM_STANDALONE, SUP_MODULE_MM_CORE_STANDALONE): - raise Warning("Unknown FV type '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) + raise Warning("Unknown FV type '%s'" % self._Token, self.FileName, self.CurrentLineNumber) - if not self.__IsToken("="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__IsKeyword("$(NAMED_GUID)"): - if not self.__GetNextWord(): + if not self._IsKeyword("$(NAMED_GUID)"): + if not self._GetNextWord(): raise Warning("expected $(NAMED_GUID)", self.FileName, self.CurrentLineNumber) - if self.__Token == 'PCD': - if not self.__IsToken( "("): + if self._Token == 'PCD': + if not self._IsToken("("): raise Warning("expected '('", self.FileName, self.CurrentLineNumber) - PcdPair = self.__GetNextPcdSettings() - if not self.__IsToken( ")"): + PcdPair = self._GetNextPcdSettings() + if not self._IsToken(")"): raise Warning("expected ')'", self.FileName, self.CurrentLineNumber) - self.__Token = 'PCD('+PcdPair[1]+'.'+PcdPair[0]+')' + self._Token = 'PCD('+PcdPair[1]+TAB_SPLIT+PcdPair[0]+')' - NameGuid = self.__Token + NameGuid = self._Token KeepReloc = None - if self.__IsKeyword('RELOCS_STRIPPED') or self.__IsKeyword('RELOCS_RETAINED'): - if self.__FileCouldHaveRelocFlag(Type): - if self.__Token == 'RELOCS_STRIPPED': + if self._IsKeyword('RELOCS_STRIPPED') or self._IsKeyword('RELOCS_RETAINED'): + if self._FileCouldHaveRelocFlag(Type): + if self._Token == 'RELOCS_STRIPPED': KeepReloc = False else: KeepReloc = True @@ -3729,111 +3645,109 @@ class FdfParser: raise Warning("File type %s could not have reloc strip flag%d" % (Type, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber) KeyStringList = [] - if self.__GetNextToken(): - if TokenFindPattern.match(self.__Token): - KeyStringList.append(self.__Token) - if self.__IsToken(","): - while self.__GetNextToken(): - if not TokenFindPattern.match(self.__Token): + if self._GetNextToken(): + if TokenFindPattern.match(self._Token): + KeyStringList.append(self._Token) + if self._IsToken(TAB_COMMA_SPLIT): + while self._GetNextToken(): + if not TokenFindPattern.match(self._Token): raise Warning("expected KeyString \"Target_Tag_Arch\"", self.FileName, self.CurrentLineNumber) - KeyStringList.append(self.__Token) + KeyStringList.append(self._Token) - if not self.__IsToken(","): + if not self._IsToken(TAB_COMMA_SPLIT): break else: - self.__UndoToken() + self._UndoToken() Fixed = False - if self.__IsKeyword("Fixed", True): + if self._IsKeyword("Fixed", True): Fixed = True CheckSum = False - if self.__IsKeyword("CheckSum", True): + if self._IsKeyword("CheckSum", True): CheckSum = True AlignValue = "" - if self.__GetAlignment(): - if self.__Token not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K", "64K", "128K", - "256K", "512K", "1M", "2M", "4M", "8M", "16M"): - raise Warning("Incorrect alignment '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) + if self._GetAlignment(): + if self._Token not in ALIGNMENTS: + raise Warning("Incorrect alignment '%s'" % self._Token, self.FileName, self.CurrentLineNumber) #For FFS, Auto is default option same to "" - if not self.__Token == "Auto": - AlignValue = self.__Token + if not self._Token == "Auto": + AlignValue = self._Token - if self.__IsToken("{"): + if self._IsToken("{"): # Complex file rule expected - Rule = RuleComplexFile.RuleComplexFile() - Rule.FvFileType = Type - Rule.NameGuid = NameGuid - Rule.Alignment = AlignValue - Rule.CheckSum = CheckSum - Rule.Fixed = Fixed - Rule.KeyStringList = KeyStringList + NewRule = RuleComplexFile() + NewRule.FvFileType = Type + NewRule.NameGuid = NameGuid + NewRule.Alignment = AlignValue + NewRule.CheckSum = CheckSum + NewRule.Fixed = Fixed + NewRule.KeyStringList = KeyStringList if KeepReloc is not None: - Rule.KeepReloc = KeepReloc + NewRule.KeepReloc = KeepReloc while True: - IsEncapsulate = self.__GetRuleEncapsulationSection(Rule) - IsLeaf = self.__GetEfiSection(Rule) + IsEncapsulate = self._GetRuleEncapsulationSection(NewRule) + IsLeaf = self._GetEfiSection(NewRule) if not IsEncapsulate and not IsLeaf: break - if not self.__IsToken("}"): + if not self._IsToken("}"): raise Warning("expected '}'", self.FileName, self.CurrentLineNumber) - return Rule + return NewRule else: # Simple file rule expected - if not self.__GetNextWord(): + if not self._GetNextWord(): raise Warning("expected leaf section type", self.FileName, self.CurrentLineNumber) - SectionName = self.__Token + SectionName = self._Token if SectionName not in ("COMPAT16", BINARY_FILE_TYPE_PE32, BINARY_FILE_TYPE_PIC, BINARY_FILE_TYPE_TE, "FV_IMAGE", "RAW", BINARY_FILE_TYPE_DXE_DEPEX,\ BINARY_FILE_TYPE_UI, BINARY_FILE_TYPE_PEI_DEPEX, "VERSION", "SUBTYPE_GUID", BINARY_FILE_TYPE_SMM_DEPEX): raise Warning("Unknown leaf section name '%s'" % SectionName, self.FileName, self.CurrentLineNumber) - if self.__IsKeyword("Fixed", True): + if self._IsKeyword("Fixed", True): Fixed = True - if self.__IsKeyword("CheckSum", True): + if self._IsKeyword("CheckSum", True): CheckSum = True SectAlignment = "" - if self.__GetAlignment(): - if self.__Token not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K", "64K", "128K", - "256K", "512K", "1M", "2M", "4M", "8M", "16M"): - raise Warning("Incorrect alignment '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) - if self.__Token == 'Auto' and (not SectionName == BINARY_FILE_TYPE_PE32) and (not SectionName == BINARY_FILE_TYPE_TE): + if self._GetAlignment(): + if self._Token not in ALIGNMENTS: + raise Warning("Incorrect alignment '%s'" % self._Token, self.FileName, self.CurrentLineNumber) + if self._Token == 'Auto' and (not SectionName == BINARY_FILE_TYPE_PE32) and (not SectionName == BINARY_FILE_TYPE_TE): raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber) - SectAlignment = self.__Token + SectAlignment = self._Token Ext = None - if self.__IsToken('|'): - Ext = self.__GetFileExtension() - elif not self.__GetNextToken(): + if self._IsToken(TAB_VALUE_SPLIT): + Ext = self._GetFileExtension() + elif not self._GetNextToken(): raise Warning("expected File name", self.FileName, self.CurrentLineNumber) - Rule = RuleSimpleFile.RuleSimpleFile() - Rule.SectionType = SectionName - Rule.FvFileType = Type - Rule.NameGuid = NameGuid - Rule.Alignment = AlignValue - Rule.SectAlignment = SectAlignment - Rule.CheckSum = CheckSum - Rule.Fixed = Fixed - Rule.KeyStringList = KeyStringList + NewRule = RuleSimpleFile() + NewRule.SectionType = SectionName + NewRule.FvFileType = Type + NewRule.NameGuid = NameGuid + NewRule.Alignment = AlignValue + NewRule.SectAlignment = SectAlignment + NewRule.CheckSum = CheckSum + NewRule.Fixed = Fixed + NewRule.KeyStringList = KeyStringList if KeepReloc is not None: - Rule.KeepReloc = KeepReloc - Rule.FileExtension = Ext - Rule.FileName = self.__Token - return Rule + NewRule.KeepReloc = KeepReloc + NewRule.FileExtension = Ext + NewRule.FileName = self._Token + return NewRule - ## __GetEfiSection() method + ## _GetEfiSection() method # # Get section list for Rule # @@ -3842,127 +3756,124 @@ class FdfParser: # @retval True Successfully find section statement # @retval False Not able to find section statement # - def __GetEfiSection(self, Obj): - + def _GetEfiSection(self, Obj): OldPos = self.GetFileBufferPos() - if not self.__GetNextWord(): + if not self._GetNextWord(): return False - SectionName = self.__Token + SectionName = self._Token if SectionName not in ("COMPAT16", BINARY_FILE_TYPE_PE32, BINARY_FILE_TYPE_PIC, BINARY_FILE_TYPE_TE, "FV_IMAGE", "RAW", BINARY_FILE_TYPE_DXE_DEPEX,\ BINARY_FILE_TYPE_UI, "VERSION", BINARY_FILE_TYPE_PEI_DEPEX, BINARY_FILE_TYPE_GUID, BINARY_FILE_TYPE_SMM_DEPEX): - self.__UndoToken() + self._UndoToken() return False if SectionName == "FV_IMAGE": - FvImageSectionObj = FvImageSection.FvImageSection() - if self.__IsKeyword("FV_IMAGE"): + FvImageSectionObj = FvImageSection() + if self._IsKeyword("FV_IMAGE"): pass - if self.__IsToken( "{"): - FvObj = Fv.FV() - self.__GetDefineStatements(FvObj) - self.__GetBlockStatement(FvObj) - self.__GetSetStatements(FvObj) - self.__GetFvAlignment(FvObj) - self.__GetFvAttributes(FvObj) - self.__GetAprioriSection(FvObj) - self.__GetAprioriSection(FvObj) + if self._IsToken("{"): + FvObj = FV() + self._GetDefineStatements(FvObj) + self._GetBlockStatement(FvObj) + self._GetSetStatements(FvObj) + self._GetFvAlignment(FvObj) + self._GetFvAttributes(FvObj) + self._GetAprioriSection(FvObj) + self._GetAprioriSection(FvObj) while True: - IsInf = self.__GetInfStatement(FvObj) - IsFile = self.__GetFileStatement(FvObj) + IsInf = self._GetInfStatement(FvObj) + IsFile = self._GetFileStatement(FvObj) if not IsInf and not IsFile: break - if not self.__IsToken( "}"): + if not self._IsToken("}"): raise Warning("expected '}'", self.FileName, self.CurrentLineNumber) FvImageSectionObj.Fv = FvObj FvImageSectionObj.FvName = None else: - if not self.__IsKeyword(BINARY_FILE_TYPE_FV): - raise Warning("expected BINARY_FILE_TYPE_FV", self.FileName, self.CurrentLineNumber) - FvImageSectionObj.FvFileType = self.__Token + if not self._IsKeyword(BINARY_FILE_TYPE_FV): + raise Warning("expected 'FV'", self.FileName, self.CurrentLineNumber) + FvImageSectionObj.FvFileType = self._Token - if self.__GetAlignment(): - if self.__Token not in ("8", "16", "32", "64", "128", "512", "1K", "4K", "32K", "64K", "128K", - "256K", "512K", "1M", "2M", "4M", "8M", "16M"): - raise Warning("Incorrect alignment '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) - FvImageSectionObj.Alignment = self.__Token + if self._GetAlignment(): + if self._Token not in ALIGNMENT_NOAUTO: + raise Warning("Incorrect alignment '%s'" % self._Token, self.FileName, self.CurrentLineNumber) + FvImageSectionObj.Alignment = self._Token - if self.__IsToken('|'): - FvImageSectionObj.FvFileExtension = self.__GetFileExtension() - elif self.__GetNextToken(): - if self.__Token not in ("}", "COMPAT16", BINARY_FILE_TYPE_PE32, BINARY_FILE_TYPE_PIC, BINARY_FILE_TYPE_TE, "FV_IMAGE", "RAW", BINARY_FILE_TYPE_DXE_DEPEX,\ + if self._IsToken(TAB_VALUE_SPLIT): + FvImageSectionObj.FvFileExtension = self._GetFileExtension() + elif self._GetNextToken(): + if self._Token not in ("}", "COMPAT16", BINARY_FILE_TYPE_PE32, BINARY_FILE_TYPE_PIC, BINARY_FILE_TYPE_TE, "FV_IMAGE", "RAW", BINARY_FILE_TYPE_DXE_DEPEX,\ BINARY_FILE_TYPE_UI, "VERSION", BINARY_FILE_TYPE_PEI_DEPEX, BINARY_FILE_TYPE_GUID, BINARY_FILE_TYPE_SMM_DEPEX): - FvImageSectionObj.FvFileName = self.__Token + FvImageSectionObj.FvFileName = self._Token else: - self.__UndoToken() + self._UndoToken() else: raise Warning("expected FV file name", self.FileName, self.CurrentLineNumber) Obj.SectionList.append(FvImageSectionObj) return True - EfiSectionObj = EfiSection.EfiSection() + EfiSectionObj = EfiSection() EfiSectionObj.SectionType = SectionName - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected file type", self.FileName, self.CurrentLineNumber) - if self.__Token == "STRING": - if not self.__RuleSectionCouldHaveString(EfiSectionObj.SectionType): + if self._Token == "STRING": + if not self._RuleSectionCouldHaveString(EfiSectionObj.SectionType): raise Warning("%s section could NOT have string data%d" % (EfiSectionObj.SectionType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber) - if not self.__IsToken('='): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected Quoted String", self.FileName, self.CurrentLineNumber) - if self.__GetStringData(): - EfiSectionObj.StringData = self.__Token + if self._GetStringData(): + EfiSectionObj.StringData = self._Token - if self.__IsKeyword("BUILD_NUM"): - if not self.__RuleSectionCouldHaveBuildNum(EfiSectionObj.SectionType): + if self._IsKeyword("BUILD_NUM"): + if not self._RuleSectionCouldHaveBuildNum(EfiSectionObj.SectionType): raise Warning("%s section could NOT have BUILD_NUM%d" % (EfiSectionObj.SectionType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber) - if not self.__IsToken("="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected Build number", self.FileName, self.CurrentLineNumber) - EfiSectionObj.BuildNum = self.__Token + EfiSectionObj.BuildNum = self._Token else: - EfiSectionObj.FileType = self.__Token - self.__CheckRuleSectionFileType(EfiSectionObj.SectionType, EfiSectionObj.FileType) + EfiSectionObj.FileType = self._Token + self._CheckRuleSectionFileType(EfiSectionObj.SectionType, EfiSectionObj.FileType) - if self.__IsKeyword("Optional"): - if not self.__RuleSectionCouldBeOptional(EfiSectionObj.SectionType): + if self._IsKeyword("Optional"): + if not self._RuleSectionCouldBeOptional(EfiSectionObj.SectionType): raise Warning("%s section could NOT be optional%d" % (EfiSectionObj.SectionType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber) EfiSectionObj.Optional = True - if self.__IsKeyword("BUILD_NUM"): - if not self.__RuleSectionCouldHaveBuildNum(EfiSectionObj.SectionType): + if self._IsKeyword("BUILD_NUM"): + if not self._RuleSectionCouldHaveBuildNum(EfiSectionObj.SectionType): raise Warning("%s section could NOT have BUILD_NUM%d" % (EfiSectionObj.SectionType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber) - if not self.__IsToken("="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected Build number", self.FileName, self.CurrentLineNumber) - EfiSectionObj.BuildNum = self.__Token + EfiSectionObj.BuildNum = self._Token - if self.__GetAlignment(): - if self.__Token not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K", "64K", "128K", - "256K", "512K", "1M", "2M", "4M", "8M", "16M"): - raise Warning("Incorrect alignment '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) - if self.__Token == 'Auto' and (not SectionName == BINARY_FILE_TYPE_PE32) and (not SectionName == BINARY_FILE_TYPE_TE): + if self._GetAlignment(): + if self._Token not in ALIGNMENTS: + raise Warning("Incorrect alignment '%s'" % self._Token, self.FileName, self.CurrentLineNumber) + if self._Token == 'Auto' and (not SectionName == BINARY_FILE_TYPE_PE32) and (not SectionName == BINARY_FILE_TYPE_TE): raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber) - EfiSectionObj.Alignment = self.__Token + EfiSectionObj.Alignment = self._Token - if self.__IsKeyword('RELOCS_STRIPPED') or self.__IsKeyword('RELOCS_RETAINED'): - if self.__SectionCouldHaveRelocFlag(EfiSectionObj.SectionType): - if self.__Token == 'RELOCS_STRIPPED': + if self._IsKeyword('RELOCS_STRIPPED') or self._IsKeyword('RELOCS_RETAINED'): + if self._SectionCouldHaveRelocFlag(EfiSectionObj.SectionType): + if self._Token == 'RELOCS_STRIPPED': EfiSectionObj.KeepReloc = False else: EfiSectionObj.KeepReloc = True @@ -3972,35 +3883,35 @@ class FdfParser: raise Warning("Section type %s could not have reloc strip flag" % EfiSectionObj.SectionType, self.FileName, self.CurrentLineNumber) - if self.__IsToken('|'): - EfiSectionObj.FileExtension = self.__GetFileExtension() - elif self.__GetNextToken(): - if self.__Token not in ("}", "COMPAT16", BINARY_FILE_TYPE_PE32, BINARY_FILE_TYPE_PIC, BINARY_FILE_TYPE_TE, "FV_IMAGE", "RAW", BINARY_FILE_TYPE_DXE_DEPEX,\ + if self._IsToken(TAB_VALUE_SPLIT): + EfiSectionObj.FileExtension = self._GetFileExtension() + elif self._GetNextToken(): + if self._Token not in ("}", "COMPAT16", BINARY_FILE_TYPE_PE32, BINARY_FILE_TYPE_PIC, BINARY_FILE_TYPE_TE, "FV_IMAGE", "RAW", BINARY_FILE_TYPE_DXE_DEPEX,\ BINARY_FILE_TYPE_UI, "VERSION", BINARY_FILE_TYPE_PEI_DEPEX, BINARY_FILE_TYPE_GUID, BINARY_FILE_TYPE_SMM_DEPEX): - if self.__Token.startswith('PCD'): - self.__UndoToken() - self.__GetNextWord() + if self._Token.startswith('PCD'): + self._UndoToken() + self._GetNextWord() - if self.__Token == 'PCD': - if not self.__IsToken( "("): + if self._Token == 'PCD': + if not self._IsToken("("): raise Warning("expected '('", self.FileName, self.CurrentLineNumber) - PcdPair = self.__GetNextPcdSettings() - if not self.__IsToken( ")"): + PcdPair = self._GetNextPcdSettings() + if not self._IsToken(")"): raise Warning("expected ')'", self.FileName, self.CurrentLineNumber) - self.__Token = 'PCD('+PcdPair[1]+'.'+PcdPair[0]+')' + self._Token = 'PCD('+PcdPair[1]+TAB_SPLIT+PcdPair[0]+')' - EfiSectionObj.FileName = self.__Token + EfiSectionObj.FileName = self._Token else: - self.__UndoToken() + self._UndoToken() else: raise Warning("expected section file name", self.FileName, self.CurrentLineNumber) Obj.SectionList.append(EfiSectionObj) return True - ## __RuleSectionCouldBeOptional() method + ## _RuleSectionCouldBeOptional() method # # Get whether a section could be optional # @@ -4009,13 +3920,13 @@ class FdfParser: # @retval False section never optional # @staticmethod - def __RuleSectionCouldBeOptional(SectionType): + def _RuleSectionCouldBeOptional(SectionType): if SectionType in (BINARY_FILE_TYPE_DXE_DEPEX, BINARY_FILE_TYPE_UI, "VERSION", BINARY_FILE_TYPE_PEI_DEPEX, "RAW", BINARY_FILE_TYPE_SMM_DEPEX): return True else: return False - ## __RuleSectionCouldHaveBuildNum() method + ## _RuleSectionCouldHaveBuildNum() method # # Get whether a section could have build number information # @@ -4024,13 +3935,13 @@ class FdfParser: # @retval False section never have build number information # @staticmethod - def __RuleSectionCouldHaveBuildNum(SectionType): + def _RuleSectionCouldHaveBuildNum(SectionType): if SectionType in ("VERSION"): return True else: return False - ## __RuleSectionCouldHaveString() method + ## _RuleSectionCouldHaveString() method # # Get whether a section could have string # @@ -4039,13 +3950,13 @@ class FdfParser: # @retval False section never have string # @staticmethod - def __RuleSectionCouldHaveString(SectionType): + def _RuleSectionCouldHaveString(SectionType): if SectionType in (BINARY_FILE_TYPE_UI, "VERSION"): return True else: return False - ## __CheckRuleSectionFileType() method + ## _CheckRuleSectionFileType() method # # Get whether a section matches a file type # @@ -4053,7 +3964,7 @@ class FdfParser: # @param SectionType The section type to check # @param FileType The file type to check # - def __CheckRuleSectionFileType(self, SectionType, FileType): + def _CheckRuleSectionFileType(self, SectionType, FileType): if SectionType == "COMPAT16": if FileType not in ("COMPAT16", "SEC_COMPAT16"): raise Warning("Incorrect section file type '%s'" % FileType, self.FileName, self.CurrentLineNumber) @@ -4085,53 +3996,53 @@ class FdfParser: if FileType not in (BINARY_FILE_TYPE_PE32, "SEC_GUID"): raise Warning("Incorrect section file type '%s'" % FileType, self.FileName, self.CurrentLineNumber) - ## __GetRuleEncapsulationSection() method + ## _GetRuleEncapsulationSection() method # # Get encapsulation section for Rule # # @param self The object pointer - # @param Rule for whom section is got + # @param theRule for whom section is got # @retval True Successfully find section statement # @retval False Not able to find section statement # - def __GetRuleEncapsulationSection(self, Rule): - if self.__IsKeyword( "COMPRESS"): + def _GetRuleEncapsulationSection(self, theRule): + if self._IsKeyword("COMPRESS"): Type = "PI_STD" - if self.__IsKeyword("PI_STD") or self.__IsKeyword("PI_NONE"): - Type = self.__Token + if self._IsKeyword("PI_STD") or self._IsKeyword("PI_NONE"): + Type = self._Token - if not self.__IsToken("{"): + if not self._IsToken("{"): raise Warning("expected '{'", self.FileName, self.CurrentLineNumber) - CompressSectionObj = CompressSection.CompressSection() + CompressSectionObj = CompressSection() CompressSectionObj.CompType = Type # Recursive sections... while True: - IsEncapsulate = self.__GetRuleEncapsulationSection(CompressSectionObj) - IsLeaf = self.__GetEfiSection(CompressSectionObj) + IsEncapsulate = self._GetRuleEncapsulationSection(CompressSectionObj) + IsLeaf = self._GetEfiSection(CompressSectionObj) if not IsEncapsulate and not IsLeaf: break - if not self.__IsToken( "}"): + if not self._IsToken("}"): raise Warning("expected '}'", self.FileName, self.CurrentLineNumber) - Rule.SectionList.append(CompressSectionObj) + theRule.SectionList.append(CompressSectionObj) return True - elif self.__IsKeyword( "GUIDED"): + elif self._IsKeyword("GUIDED"): GuidValue = None - if self.__GetNextGuid(): - GuidValue = self.__Token + if self._GetNextGuid(): + GuidValue = self._Token - if self.__IsKeyword( "$(NAMED_GUID)"): - GuidValue = self.__Token + if self._IsKeyword("$(NAMED_GUID)"): + GuidValue = self._Token - AttribDict = self.__GetGuidAttrib() + AttribDict = self._GetGuidAttrib() - if not self.__IsToken("{"): + if not self._IsToken("{"): raise Warning("expected '{'", self.FileName, self.CurrentLineNumber) - GuidSectionObj = GuidSection.GuidSection() + GuidSectionObj = GuidSection() GuidSectionObj.NameGuid = GuidValue GuidSectionObj.SectionType = "GUIDED" GuidSectionObj.ProcessRequired = AttribDict["PROCESSING_REQUIRED"] @@ -4140,20 +4051,20 @@ class FdfParser: # Efi sections... while True: - IsEncapsulate = self.__GetRuleEncapsulationSection(GuidSectionObj) - IsLeaf = self.__GetEfiSection(GuidSectionObj) + IsEncapsulate = self._GetRuleEncapsulationSection(GuidSectionObj) + IsLeaf = self._GetEfiSection(GuidSectionObj) if not IsEncapsulate and not IsLeaf: break - if not self.__IsToken( "}"): + if not self._IsToken("}"): raise Warning("expected '}'", self.FileName, self.CurrentLineNumber) - Rule.SectionList.append(GuidSectionObj) + theRule.SectionList.append(GuidSectionObj) return True return False - ## __GetVtf() method + ## _GetVtf() method # # Get VTF section contents and store its data into VTF list of self.Profile # @@ -4161,69 +4072,69 @@ class FdfParser: # @retval True Successfully find a VTF # @retval False Not able to find a VTF # - def __GetVtf(self): - if not self.__GetNextToken(): + def _GetVtf(self): + if not self._GetNextToken(): return False - S = self.__Token.upper() - if S.startswith("[") and not S.startswith("[VTF."): + S = self._Token.upper() + if S.startswith(TAB_SECTION_START) and not S.startswith("[VTF."): self.SectionParser(S) - self.__UndoToken() + self._UndoToken() return False - self.__UndoToken() - if not self.__IsToken("[VTF.", True): + self._UndoToken() + if not self._IsToken("[VTF.", True): FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber) #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \ - # % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine) + # % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine:], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine) raise Warning("expected [VTF.]", self.FileName, self.CurrentLineNumber) - if not self.__SkipToToken("."): + if not self._SkipToToken(TAB_SPLIT): raise Warning("expected '.'", self.FileName, self.CurrentLineNumber) - Arch = self.__SkippedChars.rstrip(".").upper() - if Arch not in ("IA32", "X64", "IPF", "ARM", "AARCH64"): + Arch = self._SkippedChars.rstrip(TAB_SPLIT).upper() + if Arch not in {TAB_ARCH_IA32, TAB_ARCH_X64, TAB_ARCH_IPF, TAB_ARCH_ARM, TAB_ARCH_AARCH64}: raise Warning("Unknown Arch '%s'" % Arch, self.FileName, self.CurrentLineNumber) - if not self.__GetNextWord(): + if not self._GetNextWord(): raise Warning("expected VTF name", self.FileName, self.CurrentLineNumber) - Name = self.__Token.upper() + Name = self._Token.upper() - VtfObj = Vtf.Vtf() + VtfObj = Vtf() VtfObj.UiName = Name VtfObj.KeyArch = Arch - if self.__IsToken(","): - if not self.__GetNextWord(): + if self._IsToken(TAB_COMMA_SPLIT): + if not self._GetNextWord(): raise Warning("expected Arch list", self.FileName, self.CurrentLineNumber) - if self.__Token.upper() not in ("IA32", "X64", "IPF", "ARM", "AARCH64"): - raise Warning("Unknown Arch '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) - VtfObj.ArchList = self.__Token.upper() + if self._Token.upper() not in (TAB_ARCH_IA32, TAB_ARCH_X64, TAB_ARCH_IPF, TAB_ARCH_ARM, TAB_ARCH_AARCH64): + raise Warning("Unknown Arch '%s'" % self._Token, self.FileName, self.CurrentLineNumber) + VtfObj.ArchList = self._Token.upper() - if not self.__IsToken( "]"): + if not self._IsToken(TAB_SECTION_END): raise Warning("expected ']'", self.FileName, self.CurrentLineNumber) - if self.__IsKeyword("IA32_RST_BIN"): - if not self.__IsToken("="): + if self._IsKeyword("IA32_RST_BIN"): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected Reset file", self.FileName, self.CurrentLineNumber) - VtfObj.ResetBin = self.__Token - if VtfObj.ResetBin.replace('$(WORKSPACE)', '').find('$') == -1: + VtfObj.ResetBin = self._Token + if VtfObj.ResetBin.replace(TAB_WORKSPACE, '').find('$') == -1: #check for file path ErrorCode, ErrorInfo = PathClass(NormPath(VtfObj.ResetBin), GenFdsGlobalVariable.WorkSpaceDir).Validate() if ErrorCode != 0: EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo) - while self.__GetComponentStatement(VtfObj): + while self._GetComponentStatement(VtfObj): pass self.Profile.VtfList.append(VtfObj) return True - ## __GetComponentStatement() method + ## _GetComponentStatement() method # # Get components in VTF # @@ -4232,132 +4143,132 @@ class FdfParser: # @retval True Successfully find a component # @retval False Not able to find a component # - def __GetComponentStatement(self, VtfObj): - if not self.__IsKeyword("COMP_NAME"): + def _GetComponentStatement(self, VtfObj): + if not self._IsKeyword("COMP_NAME"): return False - if not self.__IsToken("="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextWord(): + if not self._GetNextWord(): raise Warning("expected Component Name", self.FileName, self.CurrentLineNumber) - CompStatementObj = ComponentStatement.ComponentStatement() - CompStatementObj.CompName = self.__Token + CompStatementObj = ComponentStatement() + CompStatementObj.CompName = self._Token - if not self.__IsKeyword("COMP_LOC"): + if not self._IsKeyword("COMP_LOC"): raise Warning("expected COMP_LOC", self.FileName, self.CurrentLineNumber) - if not self.__IsToken("="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) CompStatementObj.CompLoc = "" - if self.__GetNextWord(): - CompStatementObj.CompLoc = self.__Token - if self.__IsToken('|'): - if not self.__GetNextWord(): + if self._GetNextWord(): + CompStatementObj.CompLoc = self._Token + if self._IsToken(TAB_VALUE_SPLIT): + if not self._GetNextWord(): raise Warning("Expected Region Name", self.FileName, self.CurrentLineNumber) - if self.__Token not in ("F", "N", "S"): #, "H", "L", "PH", "PL"): not support - raise Warning("Unknown location type '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) + if self._Token not in ("F", "N", "S"): #, "H", "L", "PH", "PL"): not support + raise Warning("Unknown location type '%s'" % self._Token, self.FileName, self.CurrentLineNumber) - CompStatementObj.FilePos = self.__Token + CompStatementObj.FilePos = self._Token else: self.CurrentLineNumber += 1 self.CurrentOffsetWithinLine = 0 - if not self.__IsKeyword("COMP_TYPE"): + if not self._IsKeyword("COMP_TYPE"): raise Warning("expected COMP_TYPE", self.FileName, self.CurrentLineNumber) - if not self.__IsToken("="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected Component type", self.FileName, self.CurrentLineNumber) - if self.__Token not in ("FIT", "PAL_B", "PAL_A", "OEM"): - if not self.__Token.startswith("0x") or len(self.__Token) < 3 or len(self.__Token) > 4 or \ - not self.__Token[2] in string.hexdigits or not self.__Token[-1] in string.hexdigits: - raise Warning("Unknown location type '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) - CompStatementObj.CompType = self.__Token + if self._Token not in ("FIT", "PAL_B", "PAL_A", "OEM"): + if not self._Token.startswith("0x") or len(self._Token) < 3 or len(self._Token) > 4 or \ + not self._Token[2] in hexdigits or not self._Token[-1] in hexdigits: + raise Warning("Unknown location type '%s'" % self._Token, self.FileName, self.CurrentLineNumber) + CompStatementObj.CompType = self._Token - if not self.__IsKeyword("COMP_VER"): + if not self._IsKeyword("COMP_VER"): raise Warning("expected COMP_VER", self.FileName, self.CurrentLineNumber) - if not self.__IsToken("="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected Component version", self.FileName, self.CurrentLineNumber) - Pattern = re.compile('-$|[0-9a-fA-F]{1,2}\.[0-9a-fA-F]{1,2}$', re.DOTALL) - if Pattern.match(self.__Token) is None: - raise Warning("Unknown version format '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) - CompStatementObj.CompVer = self.__Token + Pattern = compile('-$|[0-9a-fA-F]{1,2}\.[0-9a-fA-F]{1,2}$', DOTALL) + if Pattern.match(self._Token) is None: + raise Warning("Unknown version format '%s'" % self._Token, self.FileName, self.CurrentLineNumber) + CompStatementObj.CompVer = self._Token - if not self.__IsKeyword("COMP_CS"): + if not self._IsKeyword("COMP_CS"): raise Warning("expected COMP_CS", self.FileName, self.CurrentLineNumber) - if not self.__IsToken("="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected Component CS", self.FileName, self.CurrentLineNumber) - if self.__Token not in ("1", "0"): - raise Warning("Unknown Component CS '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) - CompStatementObj.CompCs = self.__Token + if self._Token not in ("1", "0"): + raise Warning("Unknown Component CS '%s'" % self._Token, self.FileName, self.CurrentLineNumber) + CompStatementObj.CompCs = self._Token - if not self.__IsKeyword("COMP_BIN"): + if not self._IsKeyword("COMP_BIN"): raise Warning("expected COMP_BIN", self.FileName, self.CurrentLineNumber) - if not self.__IsToken("="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected Component file", self.FileName, self.CurrentLineNumber) - CompStatementObj.CompBin = self.__Token - if CompStatementObj.CompBin != '-' and CompStatementObj.CompBin.replace('$(WORKSPACE)', '').find('$') == -1: + CompStatementObj.CompBin = self._Token + if CompStatementObj.CompBin != '-' and CompStatementObj.CompBin.replace(TAB_WORKSPACE, '').find('$') == -1: #check for file path ErrorCode, ErrorInfo = PathClass(NormPath(CompStatementObj.CompBin), GenFdsGlobalVariable.WorkSpaceDir).Validate() if ErrorCode != 0: EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo) - if not self.__IsKeyword("COMP_SYM"): + if not self._IsKeyword("COMP_SYM"): raise Warning("expected COMP_SYM", self.FileName, self.CurrentLineNumber) - if not self.__IsToken("="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected Component symbol file", self.FileName, self.CurrentLineNumber) - CompStatementObj.CompSym = self.__Token - if CompStatementObj.CompSym != '-' and CompStatementObj.CompSym.replace('$(WORKSPACE)', '').find('$') == -1: + CompStatementObj.CompSym = self._Token + if CompStatementObj.CompSym != '-' and CompStatementObj.CompSym.replace(TAB_WORKSPACE, '').find('$') == -1: #check for file path ErrorCode, ErrorInfo = PathClass(NormPath(CompStatementObj.CompSym), GenFdsGlobalVariable.WorkSpaceDir).Validate() if ErrorCode != 0: EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo) - if not self.__IsKeyword("COMP_SIZE"): + if not self._IsKeyword("COMP_SIZE"): raise Warning("expected COMP_SIZE", self.FileName, self.CurrentLineNumber) - if not self.__IsToken("="): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if self.__IsToken("-"): - CompStatementObj.CompSize = self.__Token - elif self.__GetNextDecimalNumber(): - CompStatementObj.CompSize = self.__Token - elif self.__GetNextHexNumber(): - CompStatementObj.CompSize = self.__Token + if self._IsToken("-"): + CompStatementObj.CompSize = self._Token + elif self._GetNextDecimalNumber(): + CompStatementObj.CompSize = self._Token + elif self._GetNextHexNumber(): + CompStatementObj.CompSize = self._Token else: - raise Warning("Unknown size '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) + raise Warning("Unknown size '%s'" % self._Token, self.FileName, self.CurrentLineNumber) VtfObj.ComponentStatementList.append(CompStatementObj) return True - ## __GetOptionRom() method + ## _GetOptionRom() method # # Get OptionROM section contents and store its data into OptionROM list of self.Profile # @@ -4365,38 +4276,37 @@ class FdfParser: # @retval True Successfully find a OptionROM # @retval False Not able to find a OptionROM # - def __GetOptionRom(self): - if not self.__GetNextToken(): + def _GetOptionRom(self): + if not self._GetNextToken(): return False - S = self.__Token.upper() - if S.startswith("[") and not S.startswith("[OPTIONROM."): + S = self._Token.upper() + if S.startswith(TAB_SECTION_START) and not S.startswith("[OPTIONROM."): self.SectionParser(S) - self.__UndoToken() + self._UndoToken() return False - self.__UndoToken() - if not self.__IsToken("[OptionRom.", True): - raise Warning("Unknown Keyword '%s'" % self.__Token, self.FileName, self.CurrentLineNumber) + self._UndoToken() + if not self._IsToken("[OptionRom.", True): + raise Warning("Unknown Keyword '%s'" % self._Token, self.FileName, self.CurrentLineNumber) - OptRomName = self.__GetUiName() + OptRomName = self._GetUiName() - if not self.__IsToken( "]"): + if not self._IsToken(TAB_SECTION_END): raise Warning("expected ']'", self.FileName, self.CurrentLineNumber) - OptRomObj = OptionRom.OPTIONROM() - OptRomObj.DriverName = OptRomName + OptRomObj = OPTIONROM(OptRomName) self.Profile.OptRomDict[OptRomName] = OptRomObj while True: - isInf = self.__GetOptRomInfStatement(OptRomObj) - isFile = self.__GetOptRomFileStatement(OptRomObj) + isInf = self._GetOptRomInfStatement(OptRomObj) + isFile = self._GetOptRomFileStatement(OptRomObj) if not isInf and not isFile: break return True - ## __GetOptRomInfStatement() method + ## _GetOptRomInfStatement() method # # Get INF statements # @@ -4405,17 +4315,17 @@ class FdfParser: # @retval True Successfully find inf statement # @retval False Not able to find inf statement # - def __GetOptRomInfStatement(self, Obj): - if not self.__IsKeyword( "INF"): + def _GetOptRomInfStatement(self, Obj): + if not self._IsKeyword("INF"): return False - ffsInf = OptRomInfStatement.OptRomInfStatement() - self.__GetInfOptions( ffsInf) + ffsInf = OptRomInfStatement() + self._GetInfOptions(ffsInf) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected INF file path", self.FileName, self.CurrentLineNumber) - ffsInf.InfFileName = self.__Token - if ffsInf.InfFileName.replace('$(WORKSPACE)', '').find('$') == -1: + ffsInf.InfFileName = self._Token + if ffsInf.InfFileName.replace(TAB_WORKSPACE, '').find('$') == -1: #check for file path ErrorCode, ErrorInfo = PathClass(NormPath(ffsInf.InfFileName), GenFdsGlobalVariable.WorkSpaceDir).Validate() if ErrorCode != 0: @@ -4434,71 +4344,71 @@ class FdfParser: self.Profile.InfDict['ArchTBD'].append(ffsInf.InfFileName) - self.__GetOptRomOverrides (ffsInf) + self._GetOptRomOverrides (ffsInf) Obj.FfsList.append(ffsInf) return True - ## __GetOptRomOverrides() method + ## _GetOptRomOverrides() method # # Get overrides for OptROM INF & FILE # # @param self The object pointer # @param FfsInfObj for whom overrides is got # - def __GetOptRomOverrides(self, Obj): - if self.__IsToken('{'): - Overrides = OptRomInfStatement.OverrideAttribs() + def _GetOptRomOverrides(self, Obj): + if self._IsToken('{'): + Overrides = OverrideAttribs() while True: - if self.__IsKeyword( "PCI_VENDOR_ID"): - if not self.__IsToken( "="): + if self._IsKeyword("PCI_VENDOR_ID"): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextHexNumber(): + if not self._GetNextHexNumber(): raise Warning("expected Hex vendor id", self.FileName, self.CurrentLineNumber) - Overrides.PciVendorId = self.__Token + Overrides.PciVendorId = self._Token continue - if self.__IsKeyword( "PCI_CLASS_CODE"): - if not self.__IsToken( "="): + if self._IsKeyword("PCI_CLASS_CODE"): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextHexNumber(): + if not self._GetNextHexNumber(): raise Warning("expected Hex class code", self.FileName, self.CurrentLineNumber) - Overrides.PciClassCode = self.__Token + Overrides.PciClassCode = self._Token continue - if self.__IsKeyword( "PCI_DEVICE_ID"): - if not self.__IsToken( "="): + if self._IsKeyword("PCI_DEVICE_ID"): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextHexNumber(): + if not self._GetNextHexNumber(): raise Warning("expected Hex device id", self.FileName, self.CurrentLineNumber) - Overrides.PciDeviceId = self.__Token + Overrides.PciDeviceId = self._Token continue - if self.__IsKeyword( "PCI_REVISION"): - if not self.__IsToken( "="): + if self._IsKeyword("PCI_REVISION"): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextHexNumber(): + if not self._GetNextHexNumber(): raise Warning("expected Hex revision", self.FileName, self.CurrentLineNumber) - Overrides.PciRevision = self.__Token + Overrides.PciRevision = self._Token continue - if self.__IsKeyword( "PCI_COMPRESS"): - if not self.__IsToken( "="): + if self._IsKeyword("PCI_COMPRESS"): + if not self._IsToken(TAB_EQUAL_SPLIT): raise Warning("expected '='", self.FileName, self.CurrentLineNumber) - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected TRUE/FALSE for compress", self.FileName, self.CurrentLineNumber) - Overrides.NeedCompress = self.__Token.upper() == 'TRUE' + Overrides.NeedCompress = self._Token.upper() == 'TRUE' continue - if self.__IsToken( "}"): + if self._IsToken("}"): break else: EdkLogger.error("FdfParser", FORMAT_INVALID, File=self.FileName, Line=self.CurrentLineNumber) Obj.OverrideAttribs = Overrides - ## __GetOptRomFileStatement() method + ## _GetOptRomFileStatement() method # # Get FILE statements # @@ -4507,33 +4417,33 @@ class FdfParser: # @retval True Successfully find FILE statement # @retval False Not able to find FILE statement # - def __GetOptRomFileStatement(self, Obj): - if not self.__IsKeyword( "FILE"): + def _GetOptRomFileStatement(self, Obj): + if not self._IsKeyword("FILE"): return False - FfsFileObj = OptRomFileStatement.OptRomFileStatement() + FfsFileObj = OptRomFileStatement() - if not self.__IsKeyword("EFI") and not self.__IsKeyword(BINARY_FILE_TYPE_BIN): + if not self._IsKeyword("EFI") and not self._IsKeyword(BINARY_FILE_TYPE_BIN): raise Warning("expected Binary type (EFI/BIN)", self.FileName, self.CurrentLineNumber) - FfsFileObj.FileType = self.__Token + FfsFileObj.FileType = self._Token - if not self.__GetNextToken(): + if not self._GetNextToken(): raise Warning("expected File path", self.FileName, self.CurrentLineNumber) - FfsFileObj.FileName = self.__Token - if FfsFileObj.FileName.replace('$(WORKSPACE)', '').find('$') == -1: + FfsFileObj.FileName = self._Token + if FfsFileObj.FileName.replace(TAB_WORKSPACE, '').find('$') == -1: #check for file path ErrorCode, ErrorInfo = PathClass(NormPath(FfsFileObj.FileName), GenFdsGlobalVariable.WorkSpaceDir).Validate() if ErrorCode != 0: EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo) if FfsFileObj.FileType == 'EFI': - self.__GetOptRomOverrides(FfsFileObj) + self._GetOptRomOverrides(FfsFileObj) Obj.FfsList.append(FfsFileObj) return True - ## __GetCapInFd() method + ## _GetCapInFd() method # # Get Cap list contained in FD # @@ -4541,7 +4451,7 @@ class FdfParser: # @param FdName FD name # @retval CapList List of Capsule in FD # - def __GetCapInFd (self, FdName): + def _GetCapInFd (self, FdName): CapList = [] if FdName.upper() in self.Profile.FdDict: FdObj = self.Profile.FdDict[FdName.upper()] @@ -4554,7 +4464,7 @@ class FdfParser: CapList.append(elementRegionData.upper()) return CapList - ## __GetReferencedFdCapTuple() method + ## _GetReferencedFdCapTuple() method # # Get FV and FD list referenced by a capsule image # @@ -4563,22 +4473,22 @@ class FdfParser: # @param RefFdList referenced FD by section # @param RefFvList referenced FV by section # - def __GetReferencedFdCapTuple(self, CapObj, RefFdList = [], RefFvList = []): - for CapsuleDataObj in CapObj.CapsuleDataList : + def _GetReferencedFdCapTuple(self, CapObj, RefFdList = [], RefFvList = []): + for CapsuleDataObj in CapObj.CapsuleDataList: if hasattr(CapsuleDataObj, 'FvName') and CapsuleDataObj.FvName is not None and CapsuleDataObj.FvName.upper() not in RefFvList: RefFvList.append (CapsuleDataObj.FvName.upper()) elif hasattr(CapsuleDataObj, 'FdName') and CapsuleDataObj.FdName is not None and CapsuleDataObj.FdName.upper() not in RefFdList: RefFdList.append (CapsuleDataObj.FdName.upper()) elif CapsuleDataObj.Ffs is not None: - if isinstance(CapsuleDataObj.Ffs, FfsFileStatement.FileStatement): + if isinstance(CapsuleDataObj.Ffs, FileStatement): if CapsuleDataObj.Ffs.FvName is not None and CapsuleDataObj.Ffs.FvName.upper() not in RefFvList: RefFvList.append(CapsuleDataObj.Ffs.FvName.upper()) elif CapsuleDataObj.Ffs.FdName is not None and CapsuleDataObj.Ffs.FdName.upper() not in RefFdList: RefFdList.append(CapsuleDataObj.Ffs.FdName.upper()) else: - self.__GetReferencedFdFvTupleFromSection(CapsuleDataObj.Ffs, RefFdList, RefFvList) + self._GetReferencedFdFvTupleFromSection(CapsuleDataObj.Ffs, RefFdList, RefFvList) - ## __GetFvInFd() method + ## _GetFvInFd() method # # Get FV list contained in FD # @@ -4586,7 +4496,7 @@ class FdfParser: # @param FdName FD name # @retval FvList list of FV in FD # - def __GetFvInFd (self, FdName): + def _GetFvInFd (self, FdName): FvList = [] if FdName.upper() in self.Profile.FdDict: FdObj = self.Profile.FdDict[FdName.upper()] @@ -4599,7 +4509,7 @@ class FdfParser: FvList.append(elementRegionData.upper()) return FvList - ## __GetReferencedFdFvTuple() method + ## _GetReferencedFdFvTuple() method # # Get FD and FV list referenced by a FFS file # @@ -4608,17 +4518,17 @@ class FdfParser: # @param RefFdList referenced FD by section # @param RefFvList referenced FV by section # - def __GetReferencedFdFvTuple(self, FvObj, RefFdList = [], RefFvList = []): + def _GetReferencedFdFvTuple(self, FvObj, RefFdList = [], RefFvList = []): for FfsObj in FvObj.FfsList: - if isinstance(FfsObj, FfsFileStatement.FileStatement): + if isinstance(FfsObj, FileStatement): if FfsObj.FvName is not None and FfsObj.FvName.upper() not in RefFvList: RefFvList.append(FfsObj.FvName.upper()) elif FfsObj.FdName is not None and FfsObj.FdName.upper() not in RefFdList: RefFdList.append(FfsObj.FdName.upper()) else: - self.__GetReferencedFdFvTupleFromSection(FfsObj, RefFdList, RefFvList) + self._GetReferencedFdFvTupleFromSection(FfsObj, RefFdList, RefFvList) - ## __GetReferencedFdFvTupleFromSection() method + ## _GetReferencedFdFvTupleFromSection() method # # Get FD and FV list referenced by a FFS section # @@ -4627,19 +4537,19 @@ class FdfParser: # @param FdList referenced FD by section # @param FvList referenced FV by section # - def __GetReferencedFdFvTupleFromSection(self, FfsFile, FdList = [], FvList = []): + def _GetReferencedFdFvTupleFromSection(self, FfsFile, FdList = [], FvList = []): SectionStack = [] SectionStack.extend(FfsFile.SectionList) while SectionStack != []: SectionObj = SectionStack.pop() - if isinstance(SectionObj, FvImageSection.FvImageSection): + if isinstance(SectionObj, FvImageSection): if SectionObj.FvName is not None and SectionObj.FvName.upper() not in FvList: FvList.append(SectionObj.FvName.upper()) if SectionObj.Fv is not None and SectionObj.Fv.UiFvName is not None and SectionObj.Fv.UiFvName.upper() not in FvList: FvList.append(SectionObj.Fv.UiFvName.upper()) - self.__GetReferencedFdFvTuple(SectionObj.Fv, FdList, FvList) + self._GetReferencedFdFvTuple(SectionObj.Fv, FdList, FvList) - if isinstance(SectionObj, CompressSection.CompressSection) or isinstance(SectionObj, GuidSection.GuidSection): + if isinstance(SectionObj, CompressSection) or isinstance(SectionObj, GuidSection): SectionStack.extend(SectionObj.SectionList) ## CycleReferenceCheck() method @@ -4662,7 +4572,7 @@ class FdfParser: FdAnalyzedList = [] Index = 0 - while RefFvStack != [] and Index < MaxLength: + while RefFvStack and Index < MaxLength: Index = Index + 1 FvNameFromStack = RefFvStack.pop() if FvNameFromStack.upper() in self.Profile.FvDict: @@ -4672,14 +4582,14 @@ class FdfParser: RefFdList = [] RefFvList = [] - self.__GetReferencedFdFvTuple(FvObj, RefFdList, RefFvList) + self._GetReferencedFdFvTuple(FvObj, RefFdList, RefFvList) for RefFdName in RefFdList: if RefFdName in FdAnalyzedList: continue LogStr += "FV %s contains FD %s\n" % (FvNameFromStack, RefFdName) - FvInFdList = self.__GetFvInFd(RefFdName) + FvInFdList = self._GetFvInFd(RefFdName) if FvInFdList != []: for FvNameInFd in FvInFdList: LogStr += "FD %s contains FV %s\n" % (RefFdName, FvNameInFd) @@ -4725,7 +4635,7 @@ class FdfParser: RefFvList = [] RefFdList = [] - self.__GetReferencedFdCapTuple(CapObj, RefFdList, RefFvList) + self._GetReferencedFdCapTuple(CapObj, RefFdList, RefFvList) FvListLength = 0 FdListLength = 0 @@ -4735,7 +4645,7 @@ class FdfParser: continue LogStr += "Capsule %s contains FD %s\n" % (CapNameFromStack, RefFdName) - CapInFdList = self.__GetCapInFd(RefFdName) + CapInFdList = self._GetCapInFd(RefFdName) if CapInFdList != []: for CapNameInFd in CapInFdList: LogStr += "FD %s contains Capsule %s\n" % (RefFdName, CapNameInFd) @@ -4746,7 +4656,7 @@ class FdfParser: EdkLogger.info(LogStr) return True - FvInFdList = self.__GetFvInFd(RefFdName) + FvInFdList = self._GetFvInFd(RefFdName) if FvInFdList != []: for FvNameInFd in FvInFdList: LogStr += "FD %s contains FV %s\n" % (RefFdName, FvNameInFd) @@ -4767,7 +4677,7 @@ class FdfParser: FvObj = self.Profile.FvDict[RefFvName.upper()] else: continue - self.__GetReferencedFdFvTuple(FvObj, RefFdList, RefFvList) + self._GetReferencedFdFvTuple(FvObj, RefFdList, RefFvList) FvAnalyzedList.append(RefFvName) return False diff --git a/BaseTools/Source/Python/GenFds/Ffs.py b/BaseTools/Source/Python/GenFds/Ffs.py index 598b2d0231..4c1b435729 100644 --- a/BaseTools/Source/Python/GenFds/Ffs.py +++ b/BaseTools/Source/Python/GenFds/Ffs.py @@ -15,53 +15,41 @@ ## # Import Modules # -from CommonDataClass.FdfClass import FDClassObject from Common.DataType import * -## generate FFS -# -# -class Ffs(FDClassObject): - # mapping between FILE type in FDF and file type for GenFfs - FdfFvFileTypeToFileType = { - SUP_MODULE_SEC : 'EFI_FV_FILETYPE_SECURITY_CORE', - SUP_MODULE_PEI_CORE : 'EFI_FV_FILETYPE_PEI_CORE', - SUP_MODULE_PEIM : 'EFI_FV_FILETYPE_PEIM', - SUP_MODULE_DXE_CORE : 'EFI_FV_FILETYPE_DXE_CORE', - 'FREEFORM' : 'EFI_FV_FILETYPE_FREEFORM', - 'DRIVER' : 'EFI_FV_FILETYPE_DRIVER', - 'APPLICATION' : 'EFI_FV_FILETYPE_APPLICATION', - 'FV_IMAGE' : 'EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE', - 'RAW' : 'EFI_FV_FILETYPE_RAW', - 'PEI_DXE_COMBO' : 'EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER', - 'SMM' : 'EFI_FV_FILETYPE_SMM', - SUP_MODULE_SMM_CORE : 'EFI_FV_FILETYPE_SMM_CORE', - SUP_MODULE_MM_STANDALONE : 'EFI_FV_FILETYPE_MM_STANDALONE', - SUP_MODULE_MM_CORE_STANDALONE : 'EFI_FV_FILETYPE_MM_CORE_STANDALONE' - } +# mapping between FILE type in FDF and file type for GenFfs +FdfFvFileTypeToFileType = { + SUP_MODULE_SEC : 'EFI_FV_FILETYPE_SECURITY_CORE', + SUP_MODULE_PEI_CORE : 'EFI_FV_FILETYPE_PEI_CORE', + SUP_MODULE_PEIM : 'EFI_FV_FILETYPE_PEIM', + SUP_MODULE_DXE_CORE : 'EFI_FV_FILETYPE_DXE_CORE', + 'FREEFORM' : 'EFI_FV_FILETYPE_FREEFORM', + 'DRIVER' : 'EFI_FV_FILETYPE_DRIVER', + 'APPLICATION' : 'EFI_FV_FILETYPE_APPLICATION', + 'FV_IMAGE' : 'EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE', + 'RAW' : 'EFI_FV_FILETYPE_RAW', + 'PEI_DXE_COMBO' : 'EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER', + 'SMM' : 'EFI_FV_FILETYPE_SMM', + SUP_MODULE_SMM_CORE : 'EFI_FV_FILETYPE_SMM_CORE', + SUP_MODULE_MM_STANDALONE : 'EFI_FV_FILETYPE_MM_STANDALONE', + SUP_MODULE_MM_CORE_STANDALONE : 'EFI_FV_FILETYPE_MM_CORE_STANDALONE' +} - # mapping between section type in FDF and file suffix - SectionSuffix = { - BINARY_FILE_TYPE_PE32 : '.pe32', - BINARY_FILE_TYPE_PIC : '.pic', - BINARY_FILE_TYPE_TE : '.te', - BINARY_FILE_TYPE_DXE_DEPEX : '.dpx', - 'VERSION' : '.ver', - BINARY_FILE_TYPE_UI : '.ui', - 'COMPAT16' : '.com16', - 'RAW' : '.raw', - 'FREEFORM_SUBTYPE_GUID': '.guid', - 'SUBTYPE_GUID' : '.guid', - 'FV_IMAGE' : 'fv.sec', - 'COMPRESS' : '.com', - 'GUIDED' : '.guided', - BINARY_FILE_TYPE_PEI_DEPEX : '.dpx', - BINARY_FILE_TYPE_SMM_DEPEX : '.dpx' - } - - ## The constructor - # - # @param self The object pointer - # - def __init__(self): - FfsClassObject.__init__(self) +# mapping between section type in FDF and file suffix +SectionSuffix = { + BINARY_FILE_TYPE_PE32 : '.pe32', + BINARY_FILE_TYPE_PIC : '.pic', + BINARY_FILE_TYPE_TE : '.te', + BINARY_FILE_TYPE_DXE_DEPEX : '.dpx', + 'VERSION' : '.ver', + BINARY_FILE_TYPE_UI : '.ui', + 'COMPAT16' : '.com16', + 'RAW' : '.raw', + 'FREEFORM_SUBTYPE_GUID': '.guid', + 'SUBTYPE_GUID' : '.guid', + 'FV_IMAGE' : 'fv.sec', + 'COMPRESS' : '.com', + 'GUIDED' : '.guided', + BINARY_FILE_TYPE_PEI_DEPEX : '.dpx', + BINARY_FILE_TYPE_SMM_DEPEX : '.dpx' +} diff --git a/BaseTools/Source/Python/GenFds/FfsFileStatement.py b/BaseTools/Source/Python/GenFds/FfsFileStatement.py index 4c35aac76a..7479efff04 100644 --- a/BaseTools/Source/Python/GenFds/FfsFileStatement.py +++ b/BaseTools/Source/Python/GenFds/FfsFileStatement.py @@ -16,26 +16,22 @@ # Import Modules # from __future__ import absolute_import -from . import Ffs -from . import Rule -import Common.LongFilePathOs as os from io import BytesIO -import subprocess - -from .GenFdsGlobalVariable import GenFdsGlobalVariable +from struct import pack from CommonDataClass.FdfClass import FileStatementClassObject from Common import EdkLogger -from Common.BuildToolError import * -from Common.Misc import GuidStructureByteArrayToGuidString +from Common.BuildToolError import GENFDS_ERROR +from Common.Misc import GuidStructureByteArrayToGuidString, SaveFileOnChange +import Common.LongFilePathOs as os from .GuidSection import GuidSection from .FvImageSection import FvImageSection -from Common.Misc import SaveFileOnChange -from struct import * +from .Ffs import FdfFvFileTypeToFileType +from .GenFdsGlobalVariable import GenFdsGlobalVariable ## generate FFS from FILE # # -class FileStatement (FileStatementClassObject) : +class FileStatement (FileStatementClassObject): ## The constructor # # @param self The object pointer @@ -60,7 +56,7 @@ class FileStatement (FileStatementClassObject) : # def GenFfs(self, Dict = {}, FvChildAddr=[], FvParentAddr=None, IsMakefile=False, FvName=None): - if self.NameGuid is not None and self.NameGuid.startswith('PCD('): + if self.NameGuid and self.NameGuid.startswith('PCD('): PcdValue = GenFdsGlobalVariable.GetPcdValue(self.NameGuid) if len(PcdValue) == 0: EdkLogger.error("GenFds", GENFDS_ERROR, '%s NOT defined.' \ @@ -82,7 +78,7 @@ class FileStatement (FileStatementClassObject) : Dict.update(self.DefineVarDict) SectionAlignments = None - if self.FvName is not None : + if self.FvName: Buffer = BytesIO('') if self.FvName.upper() not in GenFdsGlobalVariable.FdfParser.Profile.FvDict: EdkLogger.error("GenFds", GENFDS_ERROR, "FV (%s) is NOT described in FDF file!" % (self.FvName)) @@ -90,14 +86,14 @@ class FileStatement (FileStatementClassObject) : FileName = Fv.AddToBuffer(Buffer) SectionFiles = [FileName] - elif self.FdName is not None: + elif self.FdName: if self.FdName.upper() not in GenFdsGlobalVariable.FdfParser.Profile.FdDict: EdkLogger.error("GenFds", GENFDS_ERROR, "FD (%s) is NOT described in FDF file!" % (self.FdName)) Fd = GenFdsGlobalVariable.FdfParser.Profile.FdDict.get(self.FdName.upper()) FileName = Fd.GenFd() SectionFiles = [FileName] - elif self.FileName is not None: + elif self.FileName: if hasattr(self, 'FvFileType') and self.FvFileType == 'RAW': if isinstance(self.FileName, list) and isinstance(self.SubAlignment, list) and len(self.FileName) == len(self.SubAlignment): FileContent = '' @@ -111,7 +107,7 @@ class FileStatement (FileStatementClassObject) : Content = f.read() f.close() AlignValue = 1 - if self.SubAlignment[Index] is not None: + if self.SubAlignment[Index]: AlignValue = GenFdsGlobalVariable.GetAlignment(self.SubAlignment[Index]) if AlignValue > MaxAlignValue: MaxAlignIndex = Index @@ -143,7 +139,7 @@ class FileStatement (FileStatementClassObject) : SectionFiles = [] Index = 0 SectionAlignments = [] - for section in self.SectionList : + for section in self.SectionList: Index = Index + 1 SecIndex = '%d' %Index # process the inside FvImage from FvSection or GuidSection @@ -152,7 +148,7 @@ class FileStatement (FileStatementClassObject) : section.FvAddr = FvChildAddr.pop(0) elif isinstance(section, GuidSection): section.FvAddr = FvChildAddr - if FvParentAddr is not None and isinstance(section, GuidSection): + if FvParentAddr and isinstance(section, GuidSection): section.FvParentAddr = FvParentAddr if self.KeepReloc == False: @@ -168,7 +164,7 @@ class FileStatement (FileStatementClassObject) : # FfsFileOutput = os.path.join(OutputDir, self.NameGuid + '.ffs') GenFdsGlobalVariable.GenerateFfs(FfsFileOutput, SectionFiles, - Ffs.Ffs.FdfFvFileTypeToFileType.get(self.FvFileType), + FdfFvFileTypeToFileType.get(self.FvFileType), self.NameGuid, Fixed=self.Fixed, CheckSum=self.CheckSum, @@ -177,6 +173,3 @@ class FileStatement (FileStatementClassObject) : ) return FfsFileOutput - - - diff --git a/BaseTools/Source/Python/GenFds/FfsInfStatement.py b/BaseTools/Source/Python/GenFds/FfsInfStatement.py index 6149bc81b4..c1073c96e9 100644 --- a/BaseTools/Source/Python/GenFds/FfsInfStatement.py +++ b/BaseTools/Source/Python/GenFds/FfsInfStatement.py @@ -22,7 +22,7 @@ import Common.LongFilePathOs as os from io import BytesIO from struct import * from .GenFdsGlobalVariable import GenFdsGlobalVariable -from . import Ffs +from .Ffs import SectionSuffix,FdfFvFileTypeToFileType import subprocess import sys from . import Section @@ -760,7 +760,7 @@ class FfsInfStatement(FfsInfStatementClassObject): SecNum = '%d' %Index GenSecOutputFile= self.__ExtendMacro__(Rule.NameGuid) + \ - Ffs.Ffs.SectionSuffix[SectionType] + SUP_MODULE_SEC + SecNum + SectionSuffix[SectionType] + SUP_MODULE_SEC + SecNum Index = Index + 1 OutputFile = os.path.join(self.OutputPath, GenSecOutputFile) File = GenFdsGlobalVariable.MacroExtend(File, Dict, self.CurrentArch) @@ -803,7 +803,7 @@ class FfsInfStatement(FfsInfStatementClassObject): else: SecNum = '%d' %Index GenSecOutputFile= self.__ExtendMacro__(Rule.NameGuid) + \ - Ffs.Ffs.SectionSuffix[SectionType] + SUP_MODULE_SEC + SecNum + SectionSuffix[SectionType] + SUP_MODULE_SEC + SecNum OutputFile = os.path.join(self.OutputPath, GenSecOutputFile) GenSecInputFile = GenFdsGlobalVariable.MacroExtend(GenSecInputFile, Dict, self.CurrentArch) @@ -882,7 +882,7 @@ class FfsInfStatement(FfsInfStatementClassObject): self.ModuleGuid = RegistryGuidStr GenFdsGlobalVariable.GenerateFfs(FfsOutput, InputSection, - Ffs.Ffs.FdfFvFileTypeToFileType[Rule.FvFileType], + FdfFvFileTypeToFileType[Rule.FvFileType], self.ModuleGuid, Fixed=Rule.Fixed, CheckSum=Rule.CheckSum, Align=Rule.Alignment, SectionAlign=SectionAlignments, @@ -1055,7 +1055,7 @@ class FfsInfStatement(FfsInfStatementClassObject): FfsOutput = os.path.join( self.OutputPath, self.ModuleGuid + '.ffs') GenFdsGlobalVariable.GenerateFfs(FfsOutput, InputFile, - Ffs.Ffs.FdfFvFileTypeToFileType[Rule.FvFileType], + FdfFvFileTypeToFileType[Rule.FvFileType], self.ModuleGuid, Fixed=Rule.Fixed, CheckSum=Rule.CheckSum, Align=Rule.Alignment, SectionAlign=Alignments, diff --git a/BaseTools/Source/Python/GenFds/Fv.py b/BaseTools/Source/Python/GenFds/Fv.py index c66fc38327..30525bd11f 100644 --- a/BaseTools/Source/Python/GenFds/Fv.py +++ b/BaseTools/Source/Python/GenFds/Fv.py @@ -1,4 +1,3 @@ -from __future__ import absolute_import ## @file # process FV generation # @@ -16,16 +15,13 @@ from __future__ import absolute_import ## # Import Modules # +from __future__ import absolute_import import Common.LongFilePathOs as os import subprocess from io import BytesIO from struct import * - -from . import Ffs -from . import AprioriSection from . import FfsFileStatement from .GenFdsGlobalVariable import GenFdsGlobalVariable -from CommonDataClass.FdfClass import FvClassObject from Common.Misc import SaveFileOnChange, PackGUID from Common.LongFilePathSupport import CopyLongFilePath from Common.LongFilePathSupport import OpenLongFilePath as open @@ -36,13 +32,25 @@ FV_UI_EXT_ENTY_GUID = 'A67DF1FA-8DE8-4E98-AF09-4BDF2EFFBC7C' ## generate FV # # -class FV (FvClassObject): +class FV (object): ## The constructor # # @param self The object pointer # def __init__(self): - FvClassObject.__init__(self) + self.UiFvName = None + self.CreateFileName = None + self.BlockSizeList = [] + self.DefineVarDict = {} + self.SetVarDict = {} + self.FvAlignment = None + self.FvAttributeDict = {} + self.FvNameGuid = None + self.FvNameString = None + self.AprioriSectionList = [] + self.FfsList = [] + self.BsBaseAddress = None + self.RtBaseAddress = None self.FvInfFile = None self.FvAddressFile = None self.BaseAddress = None @@ -68,7 +76,7 @@ class FV (FvClassObject): # @param MacroDict macro value pair # @retval string Generated FV file path # - def AddToBuffer (self, Buffer, BaseAddress=None, BlockSize= None, BlockNum=None, ErasePloarity='1', VtfDict=None, MacroDict = {}, Flag=False) : + def AddToBuffer (self, Buffer, BaseAddress=None, BlockSize= None, BlockNum=None, ErasePloarity='1', VtfDict=None, MacroDict = {}, Flag=False): if BaseAddress is None and self.UiFvName.upper() + 'fv' in GenFdsGlobalVariable.ImageBinDict: return GenFdsGlobalVariable.ImageBinDict[self.UiFvName.upper() + 'fv'] @@ -96,7 +104,7 @@ class FV (FvClassObject): if self.FvBaseAddress is not None: BaseAddress = self.FvBaseAddress if not Flag: - self.__InitializeInf__(BaseAddress, BlockSize, BlockNum, ErasePloarity, VtfDict) + self._InitializeInf(BaseAddress, BlockSize, BlockNum, ErasePloarity, VtfDict) # # First Process the Apriori section # @@ -114,7 +122,7 @@ class FV (FvClassObject): TAB_LINE_BREAK) # Process Modules in FfsList - for FfsFile in self.FfsList : + for FfsFile in self.FfsList: if Flag: if isinstance(FfsFile, FfsFileStatement.FileStatement): continue @@ -177,7 +185,7 @@ class FV (FvClassObject): if FvChildAddr != []: # Update Ffs again - for FfsFile in self.FfsList : + for FfsFile in self.FfsList: FileName = FfsFile.GenFfs(MacroDict, FvChildAddr, BaseAddress, IsMakefile=Flag, FvName=self.UiFvName) if GenFdsGlobalVariable.LargeFileInFvFlags[-1]: @@ -252,7 +260,7 @@ class FV (FvClassObject): return True return False - ## __InitializeInf__() + ## _InitializeInf() # # Initilize the inf file to create FV # @@ -263,7 +271,7 @@ class FV (FvClassObject): # @param ErasePolarity Flash erase polarity # @param VtfDict VTF objects # - def __InitializeInf__ (self, BaseAddress = None, BlockSize= None, BlockNum = None, ErasePloarity='1', VtfDict=None) : + def _InitializeInf (self, BaseAddress = None, BlockSize= None, BlockNum = None, ErasePloarity='1', VtfDict=None): # # Create FV inf file # @@ -275,7 +283,7 @@ class FV (FvClassObject): # Add [Options] # self.FvInfFile.writelines("[options]" + TAB_LINE_BREAK) - if BaseAddress is not None : + if BaseAddress is not None: self.FvInfFile.writelines("EFI_BASE_ADDRESS = " + \ BaseAddress + \ TAB_LINE_BREAK) @@ -294,7 +302,7 @@ class FV (FvClassObject): #set default block size is 1 self.FvInfFile.writelines("EFI_BLOCK_SIZE = 0x1" + TAB_LINE_BREAK) - for BlockSize in self.BlockSizeList : + for BlockSize in self.BlockSizeList: if BlockSize[0] is not None: self.FvInfFile.writelines("EFI_BLOCK_SIZE = " + \ '0x%X' %BlockSize[0] + \ @@ -320,9 +328,9 @@ class FV (FvClassObject): ' %s' %ErasePloarity + \ TAB_LINE_BREAK) if not (self.FvAttributeDict is None): - for FvAttribute in self.FvAttributeDict.keys() : + for FvAttribute in self.FvAttributeDict.keys(): if FvAttribute == "FvUsedSizeEnable": - if self.FvAttributeDict[FvAttribute].upper() in ('TRUE', '1') : + if self.FvAttributeDict[FvAttribute].upper() in ('TRUE', '1'): self.UsedSizeEnable = True continue self.FvInfFile.writelines("EFI_" + \ @@ -365,8 +373,8 @@ class FV (FvClassObject): Guid = FV_UI_EXT_ENTY_GUID.split('-') # # Layout: - # EFI_FIRMWARE_VOLUME_EXT_ENTRY : size 4 - # GUID : size 16 + # EFI_FIRMWARE_VOLUME_EXT_ENTRY: size 4 + # GUID: size 16 # FV UI name # Buffer += (pack('HH', (FvUiLen + 16 + 4), 0x0002) @@ -422,7 +430,6 @@ class FV (FvClassObject): FvExtHeaderFileName + \ TAB_LINE_BREAK) - # # Add [Files] # diff --git a/BaseTools/Source/Python/GenFds/FvImageSection.py b/BaseTools/Source/Python/GenFds/FvImageSection.py index 04556fc870..d6e1f3315b 100644 --- a/BaseTools/Source/Python/GenFds/FvImageSection.py +++ b/BaseTools/Source/Python/GenFds/FvImageSection.py @@ -18,7 +18,7 @@ from __future__ import absolute_import from . import Section from io import BytesIO -from .Ffs import Ffs +from .Ffs import SectionSuffix import subprocess from .GenFdsGlobalVariable import GenFdsGlobalVariable import Common.LongFilePathOs as os @@ -76,7 +76,7 @@ class FvImageSection(FvImageSectionClassObject): if FvAlignmentValue > MaxFvAlignment: MaxFvAlignment = FvAlignmentValue - OutputFile = os.path.join(OutputPath, ModuleName + SUP_MODULE_SEC + Num + Ffs.SectionSuffix.get("FV_IMAGE")) + OutputFile = os.path.join(OutputPath, ModuleName + SUP_MODULE_SEC + Num + SectionSuffix.get("FV_IMAGE")) GenFdsGlobalVariable.GenerateSection(OutputFile, [FvFileName], 'EFI_SECTION_FIRMWARE_VOLUME_IMAGE', IsMakefile=IsMakefile) OutputFileList.append(OutputFile) @@ -146,7 +146,7 @@ class FvImageSection(FvImageSectionClassObject): # # Prepare the parameter of GenSection # - OutputFile = os.path.join(OutputPath, ModuleName + SUP_MODULE_SEC + SecNum + Ffs.SectionSuffix.get("FV_IMAGE")) + OutputFile = os.path.join(OutputPath, ModuleName + SUP_MODULE_SEC + SecNum + SectionSuffix.get("FV_IMAGE")) GenFdsGlobalVariable.GenerateSection(OutputFile, [FvFileName], 'EFI_SECTION_FIRMWARE_VOLUME_IMAGE', IsMakefile=IsMakefile) OutputFileList.append(OutputFile) diff --git a/BaseTools/Source/Python/GenFds/GenFds.py b/BaseTools/Source/Python/GenFds/GenFds.py index 9dec9c5eb5..0c8091b798 100644 --- a/BaseTools/Source/Python/GenFds/GenFds.py +++ b/BaseTools/Source/Python/GenFds/GenFds.py @@ -17,34 +17,30 @@ # from __future__ import print_function from __future__ import absolute_import +from re import compile from optparse import OptionParser -import sys -import Common.LongFilePathOs as os -import linecache -from . import FdfParser -import Common.BuildToolError as BuildToolError -from .GenFdsGlobalVariable import GenFdsGlobalVariable -from Workspace.WorkspaceDatabase import WorkspaceDatabase -from Workspace.BuildClassObject import PcdClassObject -from . import RuleComplexFile -from .EfiSection import EfiSection +from sys import exit +from glob import glob +from struct import unpack +from linecache import getlines from io import BytesIO -import Common.TargetTxtClassObject as TargetTxtClassObject -import Common.ToolDefClassObject as ToolDefClassObject + +import Common.LongFilePathOs as os +from Common.TargetTxtClassObject import TargetTxtClassObject from Common.DataType import * import Common.GlobalData as GlobalData from Common import EdkLogger -from Common.StringUtils import * -from Common.Misc import DirCache, PathClass -from Common.Misc import SaveFileOnChange -from Common.Misc import ClearDuplicatedInf -from Common.Misc import GuidStructureStringToGuidString +from Common.StringUtils import NormPath +from Common.Misc import DirCache, PathClass, GuidStructureStringToGuidString +from Common.Misc import SaveFileOnChange, ClearDuplicatedInf from Common.BuildVersion import gBUILD_VERSION from Common.MultipleWorkspace import MultipleWorkspace as mws -from . import FfsFileStatement -import glob -from struct import unpack -from Common.GlobalData import gGuidPattern +from Common.BuildToolError import FatalError, GENFDS_ERROR, CODE_ERROR, FORMAT_INVALID, RESOURCE_NOT_AVAILABLE, FILE_NOT_FOUND, OPTION_MISSING, FORMAT_NOT_SUPPORTED,OPTION_VALUE_INVALID +from Workspace.WorkspaceDatabase import WorkspaceDatabase + +from .FdfParser import FdfParser, Warning +from .GenFdsGlobalVariable import GenFdsGlobalVariable +from .FfsFileStatement import FileStatement ## Version and Copyright versionNumber = "1.0" + ' ' + gBUILD_VERSION @@ -71,22 +67,22 @@ def main(): EdkLogger.Initialize() try: - if Options.verbose is not None: + if Options.verbose: EdkLogger.SetLevel(EdkLogger.VERBOSE) GenFdsGlobalVariable.VerboseMode = True - if Options.FixedAddress is not None: + if Options.FixedAddress: GenFdsGlobalVariable.FixedLoadAddress = True - if Options.quiet is not None: + if Options.quiet: EdkLogger.SetLevel(EdkLogger.QUIET) - if Options.debug is not None: + if Options.debug: EdkLogger.SetLevel(Options.debug + 1) GenFdsGlobalVariable.DebugLevel = Options.debug else: EdkLogger.SetLevel(EdkLogger.INFO) - if (Options.Workspace is None): + if not Options.Workspace: EdkLogger.error("GenFds", OPTION_MISSING, "WORKSPACE not defined", ExtraData="Please use '-w' switch to pass it or set the WORKSPACE environment variable.") elif not os.path.exists(Options.Workspace): @@ -97,7 +93,7 @@ def main(): GenFdsGlobalVariable.WorkSpaceDir = Workspace if 'EDK_SOURCE' in os.environ: GenFdsGlobalVariable.EdkSourceDir = os.path.normcase(os.environ['EDK_SOURCE']) - if (Options.debug): + if Options.debug: GenFdsGlobalVariable.VerboseLogger("Using Workspace:" + Workspace) if Options.GenfdsMultiThread: GenFdsGlobalVariable.EnableGenfdsMultiThread = True @@ -107,7 +103,7 @@ def main(): PackagesPath = os.getenv("PACKAGES_PATH") mws.setWs(GenFdsGlobalVariable.WorkSpaceDir, PackagesPath) - if (Options.filename): + if Options.filename: FdfFilename = Options.filename FdfFilename = GenFdsGlobalVariable.ReplaceWorkspaceMacro(FdfFilename) @@ -123,13 +119,13 @@ def main(): else: EdkLogger.error("GenFds", OPTION_MISSING, "Missing FDF filename") - if (Options.BuildTarget): + if Options.BuildTarget: GenFdsGlobalVariable.TargetName = Options.BuildTarget - if (Options.ToolChain): + if Options.ToolChain: GenFdsGlobalVariable.ToolChainTag = Options.ToolChain - if (Options.activePlatform): + if Options.activePlatform: ActivePlatform = Options.activePlatform ActivePlatform = GenFdsGlobalVariable.ReplaceWorkspaceMacro(ActivePlatform) @@ -139,15 +135,15 @@ def main(): if not os.path.isabs (ActivePlatform): ActivePlatform = mws.join(GenFdsGlobalVariable.WorkSpaceDir, ActivePlatform) - if not os.path.exists(ActivePlatform) : + if not os.path.exists(ActivePlatform): EdkLogger.error("GenFds", FILE_NOT_FOUND, "ActivePlatform doesn't exist!") else: EdkLogger.error("GenFds", OPTION_MISSING, "Missing active platform") - GlobalData.BuildOptionPcd = Options.OptionPcd if Options.OptionPcd else {} + GlobalData.BuildOptionPcd = Options.OptionPcd if Options.OptionPcd else {} GenFdsGlobalVariable.ActivePlatform = PathClass(NormPath(ActivePlatform)) - if (Options.ConfDirectory): + if Options.ConfDirectory: # Get alternate Conf location, if it is absolute, then just use the absolute directory name ConfDirectoryPath = os.path.normpath(Options.ConfDirectory) if ConfDirectoryPath.startswith('"'): @@ -169,7 +165,7 @@ def main(): GlobalData.gConfDirectory = GenFdsGlobalVariable.ConfDir BuildConfigurationFile = os.path.normpath(os.path.join(ConfDirectoryPath, "target.txt")) if os.path.isfile(BuildConfigurationFile) == True: - TargetTxt = TargetTxtClassObject.TargetTxtClassObject() + TargetTxt = TargetTxtClassObject() TargetTxt.LoadTargetTxtFile(BuildConfigurationFile) # if no build target given in command line, get it from target.txt if not GenFdsGlobalVariable.TargetName: @@ -237,10 +233,9 @@ def main(): GlobalData.gAllFiles = DirCache(Workspace) GlobalData.gWorkspace = Workspace - if (Options.archList) : + if Options.archList: ArchList = Options.archList.split(',') else: -# EdkLogger.error("GenFds", OPTION_MISSING, "Missing build ARCH") ArchList = BuildWorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, TAB_COMMON, Options.BuildTarget, Options.ToolChain].SupArchList TargetArchList = set(BuildWorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, TAB_COMMON, Options.BuildTarget, Options.ToolChain].SupArchList) & set(ArchList) @@ -249,9 +244,11 @@ def main(): for Arch in ArchList: GenFdsGlobalVariable.OutputDirFromDscDict[Arch] = NormPath(BuildWorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, Options.BuildTarget, Options.ToolChain].OutputDirectory) - GenFdsGlobalVariable.PlatformName = BuildWorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, Options.BuildTarget, Options.ToolChain].PlatformName - if (Options.outputDir): + # assign platform name based on last entry in ArchList + GenFdsGlobalVariable.PlatformName = BuildWorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, ArchList[-1], Options.BuildTarget, Options.ToolChain].PlatformName + + if Options.outputDir: OutputDirFromCommandLine = GenFdsGlobalVariable.ReplaceWorkspaceMacro(Options.outputDir) if not os.path.isabs (OutputDirFromCommandLine): OutputDirFromCommandLine = os.path.join(GenFdsGlobalVariable.WorkSpaceDir, OutputDirFromCommandLine) @@ -274,27 +271,27 @@ def main(): GenFdsGlobalVariable.OutputDirDict[Key] = OutputDir """ Parse Fdf file, has to place after build Workspace as FDF may contain macros from DSC file """ - FdfParserObj = FdfParser.FdfParser(FdfFilename) + FdfParserObj = FdfParser(FdfFilename) FdfParserObj.ParseFile() if FdfParserObj.CycleReferenceCheck(): EdkLogger.error("GenFds", FORMAT_NOT_SUPPORTED, "Cycle Reference Detected in FDF file") - if (Options.uiFdName) : + if Options.uiFdName: if Options.uiFdName.upper() in FdfParserObj.Profile.FdDict: GenFds.OnlyGenerateThisFd = Options.uiFdName else: EdkLogger.error("GenFds", OPTION_VALUE_INVALID, "No such an FD in FDF file: %s" % Options.uiFdName) - if (Options.uiFvName) : + if Options.uiFvName: if Options.uiFvName.upper() in FdfParserObj.Profile.FvDict: GenFds.OnlyGenerateThisFv = Options.uiFvName else: EdkLogger.error("GenFds", OPTION_VALUE_INVALID, "No such an FV in FDF file: %s" % Options.uiFvName) - if (Options.uiCapName) : + if Options.uiCapName: if Options.uiCapName.upper() in FdfParserObj.Profile.CapsuleDict: GenFds.OnlyGenerateThisCap = Options.uiCapName else: @@ -302,7 +299,7 @@ def main(): "No such a Capsule in FDF file: %s" % Options.uiCapName) GenFdsGlobalVariable.WorkSpace = BuildWorkSpace - if ArchList is not None: + if ArchList: GenFdsGlobalVariable.ArchList = ArchList # Dsc Build Data will handle Pcd Settings from CommandLine. @@ -313,10 +310,8 @@ def main(): # Record the FV Region info that may specific in the FD if FdfParserObj.Profile.FvDict and FdfParserObj.Profile.FdDict: - for Fv in FdfParserObj.Profile.FvDict: - FvObj = FdfParserObj.Profile.FvDict[Fv] - for Fd in FdfParserObj.Profile.FdDict: - FdObj = FdfParserObj.Profile.FdDict[Fd] + for FvObj in FdfParserObj.Profile.FvDict.values(): + for FdObj in FdfParserObj.Profile.FdDict.values(): for RegionObj in FdObj.RegionList: if RegionObj.RegionType != BINARY_FILE_TYPE_FV: continue @@ -338,7 +333,7 @@ def main(): """Display FV space info.""" GenFds.DisplayFvSpaceInfo(FdfParserObj) - except FdfParser.Warning as X: + except Warning as X: EdkLogger.error(X.ToolName, FORMAT_INVALID, File=X.FileName, Line=X.LineNumber, ExtraData=X.Message, RaiseError=False) ReturnCode = FORMAT_INVALID except FatalError as X: @@ -374,7 +369,6 @@ def SingleCheckCallback(option, opt_str, value, parser): # Using standard Python module optparse to parse command line option of this tool. # # @retval Opt A optparse.Values object containing the parsed options -# @retval Args Target of build command # def myOptionParser(): usage = "%prog [options] -f input_file -a arch_list -b build_target -p active_platform -t tool_chain_tag -D \"MacroName [= MacroValue]\"" @@ -404,7 +398,7 @@ def myOptionParser(): Parser.add_option("--pcd", action="append", dest="OptionPcd", help="Set PCD value by command line. Format: \"PcdName=Value\" ") Parser.add_option("--genfds-multi-thread", action="store_true", dest="GenfdsMultiThread", default=False, help="Enable GenFds multi thread to generate ffs file.") - (Options, args) = Parser.parse_args() + Options, _ = Parser.parse_args() return Options ## The class implementing the EDK2 flash image generation process @@ -414,7 +408,7 @@ def myOptionParser(): # 2. Call methods of Fd class to generate FD # 3. Call methods of Fv class to generate FV that not belong to FD # -class GenFds : +class GenFds(object): FdfParsef = None OnlyGenerateThisFd = None OnlyGenerateThisFv = None @@ -423,12 +417,13 @@ class GenFds : ## GenFd() # # @param OutputDir Output directory - # @param FdfParser FDF contents parser + # @param FdfParserObject FDF contents parser # @param Workspace The directory of workspace # @param ArchList The Arch list of platform # - def GenFd (OutputDir, FdfParser, WorkSpace, ArchList): - GenFdsGlobalVariable.SetDir ('', FdfParser, WorkSpace, ArchList) + @staticmethod + def GenFd (OutputDir, FdfParserObject, WorkSpace, ArchList): + GenFdsGlobalVariable.SetDir ('', FdfParserObject, WorkSpace, ArchList) GenFdsGlobalVariable.VerboseLogger(" Generate all Fd images and their required FV and Capsule images!") if GenFds.OnlyGenerateThisCap is not None and GenFds.OnlyGenerateThisCap.upper() in GenFdsGlobalVariable.FdfParser.Profile.CapsuleDict: @@ -470,9 +465,10 @@ class GenFds : GenFdsGlobalVariable.VerboseLogger("\n Generate all Option ROM!") for OptRomObj in GenFdsGlobalVariable.FdfParser.Profile.OptRomDict.values(): OptRomObj.AddToBuffer(None) + @staticmethod - def GenFfsMakefile(OutputDir, FdfParser, WorkSpace, ArchList, GlobalData): - GenFdsGlobalVariable.SetEnv(FdfParser, WorkSpace, ArchList, GlobalData) + def GenFfsMakefile(OutputDir, FdfParserObject, WorkSpace, ArchList, GlobalData): + GenFdsGlobalVariable.SetEnv(FdfParserObject, WorkSpace, ArchList, GlobalData) for FdObj in GenFdsGlobalVariable.FdfParser.Profile.FdDict.values(): FdObj.GenFd(Flag=True) @@ -490,6 +486,7 @@ class GenFds : # @param FvObj Whose block size to get # @retval int Block size value # + @staticmethod def GetFvBlockSize(FvObj): DefaultBlockSize = 0x1 FdObj = None @@ -524,16 +521,17 @@ class GenFds : # @param FvObj Whose block size to get # @retval None # - def DisplayFvSpaceInfo(FdfParser): + @staticmethod + def DisplayFvSpaceInfo(FdfParserObject): FvSpaceInfoList = [] MaxFvNameLength = 0 - for FvName in FdfParser.Profile.FvDict: + for FvName in FdfParserObject.Profile.FvDict: if len(FvName) > MaxFvNameLength: MaxFvNameLength = len(FvName) FvSpaceInfoFileName = os.path.join(GenFdsGlobalVariable.FvDir, FvName.upper() + '.Fv.map') if os.path.exists(FvSpaceInfoFileName): - FileLinesList = linecache.getlines(FvSpaceInfoFileName) + FileLinesList = getlines(FvSpaceInfoFileName) TotalFound = False Total = '' UsedFound = False @@ -575,6 +573,7 @@ class GenFds : # @param DscFile modules from dsc file will be preprocessed # @retval None # + @staticmethod def PreprocessImage(BuildDb, DscFile): PcdDict = BuildDb.BuildObject[DscFile, TAB_COMMON, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag].Pcds PcdValue = '' @@ -600,6 +599,7 @@ class GenFds : ModuleObj = BuildDb.BuildObject[Key, TAB_COMMON, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag] print(ModuleObj.BaseName + ' ' + ModuleObj.ModuleType) + @staticmethod def GenerateGuidXRefFile(BuildDb, ArchList, FdfParserObj): GuidXRefFileName = os.path.join(GenFdsGlobalVariable.FvDir, "Guid.xref") GuidXRefFile = BytesIO('') @@ -607,7 +607,6 @@ class GenFds : GuidDict = {} ModuleList = [] FileGuidList = [] - GuidPattern = gGuidPattern for Arch in ArchList: PlatformDataBase = BuildDb.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag] PkgList = GenFdsGlobalVariable.WorkSpace.GetPackageList(GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag) @@ -626,20 +625,16 @@ class GenFds : continue else: ModuleList.append(Module) - GuidMatch = GuidPattern.match(ModuleFile.BaseName) - if GuidMatch is not None: + if GlobalData.gGuidPattern.match(ModuleFile.BaseName): GuidXRefFile.write("%s %s\n" % (ModuleFile.BaseName, Module.BaseName)) else: GuidXRefFile.write("%s %s\n" % (Module.Guid, Module.BaseName)) - for key, item in Module.Protocols.items(): - GuidDict[key] = item - for key, item in Module.Guids.items(): - GuidDict[key] = item - for key, item in Module.Ppis.items(): - GuidDict[key] = item + GuidDict.update(Module.Protocols) + GuidDict.update(Module.Guids) + GuidDict.update(Module.Ppis) for FvName in FdfParserObj.Profile.FvDict: for FfsObj in FdfParserObj.Profile.FvDict[FvName].FfsList: - if not isinstance(FfsObj, FfsFileStatement.FileStatement): + if not isinstance(FfsObj, FileStatement): InfPath = PathClass(NormPath(mws.join(GenFdsGlobalVariable.WorkSpaceDir, FfsObj.InfFileName))) FdfModule = BuildDb.BuildObject[InfPath, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag] if FdfModule in ModuleList: @@ -647,12 +642,9 @@ class GenFds : else: ModuleList.append(FdfModule) GuidXRefFile.write("%s %s\n" % (FdfModule.Guid, FdfModule.BaseName)) - for key, item in FdfModule.Protocols.items(): - GuidDict[key] = item - for key, item in FdfModule.Guids.items(): - GuidDict[key] = item - for key, item in FdfModule.Ppis.items(): - GuidDict[key] = item + GuidDict.update(FdfModule.Protocols) + GuidDict.update(FdfModule.Guids) + GuidDict.update(FdfModule.Ppis) else: FileStatementGuid = FfsObj.NameGuid if FileStatementGuid in FileGuidList: @@ -661,13 +653,13 @@ class GenFds : FileGuidList.append(FileStatementGuid) Name = [] FfsPath = os.path.join(GenFdsGlobalVariable.FvDir, 'Ffs') - FfsPath = glob.glob(os.path.join(FfsPath, FileStatementGuid) + '*') + FfsPath = glob(os.path.join(FfsPath, FileStatementGuid) + '*') if not FfsPath: continue if not os.path.exists(FfsPath[0]): continue MatchDict = {} - ReFileEnds = re.compile('\S+(.ui)$|\S+(fv.sec.txt)$|\S+(.pe32.txt)$|\S+(.te.txt)$|\S+(.pic.txt)$|\S+(.raw.txt)$|\S+(.ffs.txt)$') + ReFileEnds = compile('\S+(.ui)$|\S+(fv.sec.txt)$|\S+(.pe32.txt)$|\S+(.te.txt)$|\S+(.pic.txt)$|\S+(.raw.txt)$|\S+(.ffs.txt)$') FileList = os.listdir(FfsPath[0]) for File in FileList: Match = ReFileEnds.search(File) @@ -724,16 +716,10 @@ class GenFds : os.remove(GuidXRefFileName) GuidXRefFile.close() - ##Define GenFd as static function - GenFd = staticmethod(GenFd) - GetFvBlockSize = staticmethod(GetFvBlockSize) - DisplayFvSpaceInfo = staticmethod(DisplayFvSpaceInfo) - PreprocessImage = staticmethod(PreprocessImage) - GenerateGuidXRefFile = staticmethod(GenerateGuidXRefFile) - if __name__ == '__main__': r = main() ## 0-127 is a safe return range, and 1 is a standard default error - if r < 0 or r > 127: r = 1 - sys.exit(r) + if r < 0 or r > 127: + r = 1 + exit(r) diff --git a/BaseTools/Source/Python/GenFds/GenFdsGlobalVariable.py b/BaseTools/Source/Python/GenFds/GenFdsGlobalVariable.py index 14578a92a9..e867693d7c 100644 --- a/BaseTools/Source/Python/GenFds/GenFdsGlobalVariable.py +++ b/BaseTools/Source/Python/GenFds/GenFdsGlobalVariable.py @@ -16,13 +16,15 @@ # Import Modules # from __future__ import print_function -import Common.LongFilePathOs as os -import sys -import subprocess -import struct -import array +from __future__ import absolute_import -from Common.BuildToolError import * +import Common.LongFilePathOs as os +from sys import stdout +from subprocess import PIPE,Popen +from struct import Struct +from array import array + +from Common.BuildToolError import COMMAND_FAILURE,GENFDS_ERROR from Common import EdkLogger from Common.Misc import SaveFileOnChange @@ -89,7 +91,7 @@ class GenFdsGlobalVariable: EFI_FIRMWARE_FILE_SYSTEM3_GUID = '5473C07A-3DCB-4dca-BD6F-1E9689E7349A' LARGE_FILE_SIZE = 0x1000000 - SectionHeader = struct.Struct("3B 1B") + SectionHeader = Struct("3B 1B") # FvName, FdName, CapName in FDF, Image file name ImageBinDict = {} @@ -97,7 +99,7 @@ class GenFdsGlobalVariable: ## LoadBuildRule # @staticmethod - def __LoadBuildRule(): + def _LoadBuildRule(): if GenFdsGlobalVariable.__BuildRuleDatabase: return GenFdsGlobalVariable.__BuildRuleDatabase BuildConfigurationFile = os.path.normpath(os.path.join(GenFdsGlobalVariable.ConfDir, "target.txt")) @@ -139,44 +141,43 @@ class GenFdsGlobalVariable: if not Arch in GenFdsGlobalVariable.OutputDirDict: return {} - BuildRuleDatabase = GenFdsGlobalVariable.__LoadBuildRule() + BuildRuleDatabase = GenFdsGlobalVariable._LoadBuildRule() if not BuildRuleDatabase: return {} PathClassObj = PathClass(Inf.MetaFile.File, GenFdsGlobalVariable.WorkSpaceDir) - Macro = {} - Macro["WORKSPACE" ] = GenFdsGlobalVariable.WorkSpaceDir - Macro["MODULE_NAME" ] = Inf.BaseName - Macro["MODULE_GUID" ] = Inf.Guid - Macro["MODULE_VERSION" ] = Inf.Version - Macro["MODULE_TYPE" ] = Inf.ModuleType - Macro["MODULE_FILE" ] = str(PathClassObj) - Macro["MODULE_FILE_BASE_NAME" ] = PathClassObj.BaseName - Macro["MODULE_RELATIVE_DIR" ] = PathClassObj.SubDir - Macro["MODULE_DIR" ] = PathClassObj.SubDir - - Macro["BASE_NAME" ] = Inf.BaseName - - Macro["ARCH" ] = Arch - Macro["TOOLCHAIN" ] = GenFdsGlobalVariable.ToolChainTag - Macro["TOOLCHAIN_TAG" ] = GenFdsGlobalVariable.ToolChainTag - Macro["TOOL_CHAIN_TAG" ] = GenFdsGlobalVariable.ToolChainTag - Macro["TARGET" ] = GenFdsGlobalVariable.TargetName - - Macro["BUILD_DIR" ] = GenFdsGlobalVariable.OutputDirDict[Arch] - Macro["BIN_DIR" ] = os.path.join(GenFdsGlobalVariable.OutputDirDict[Arch], Arch) - Macro["LIB_DIR" ] = os.path.join(GenFdsGlobalVariable.OutputDirDict[Arch], Arch) BuildDir = os.path.join( GenFdsGlobalVariable.OutputDirDict[Arch], Arch, PathClassObj.SubDir, PathClassObj.BaseName ) - Macro["MODULE_BUILD_DIR" ] = BuildDir - Macro["OUTPUT_DIR" ] = os.path.join(BuildDir, "OUTPUT") - Macro["DEBUG_DIR" ] = os.path.join(BuildDir, "DEBUG") - + BinDir = os.path.join(GenFdsGlobalVariable.OutputDirDict[Arch], Arch) + Macro = { + "WORKSPACE":GenFdsGlobalVariable.WorkSpaceDir, + "MODULE_NAME":Inf.BaseName, + "MODULE_GUID":Inf.Guid, + "MODULE_VERSION":Inf.Version, + "MODULE_TYPE":Inf.ModuleType, + "MODULE_FILE":str(PathClassObj), + "MODULE_FILE_BASE_NAME":PathClassObj.BaseName, + "MODULE_RELATIVE_DIR":PathClassObj.SubDir, + "MODULE_DIR":PathClassObj.SubDir, + "BASE_NAME":Inf.BaseName, + "ARCH":Arch, + "TOOLCHAIN":GenFdsGlobalVariable.ToolChainTag, + "TOOLCHAIN_TAG":GenFdsGlobalVariable.ToolChainTag, + "TOOL_CHAIN_TAG":GenFdsGlobalVariable.ToolChainTag, + "TARGET":GenFdsGlobalVariable.TargetName, + "BUILD_DIR":GenFdsGlobalVariable.OutputDirDict[Arch], + "BIN_DIR":BinDir, + "LIB_DIR":BinDir, + "MODULE_BUILD_DIR":BuildDir, + "OUTPUT_DIR":os.path.join(BuildDir, "OUTPUT"), + "DEBUG_DIR":os.path.join(BuildDir, "DEBUG") + } + BuildRules = {} for Type in BuildRuleDatabase.FileTypeList: #first try getting build rule by BuildRuleFamily @@ -216,12 +217,12 @@ class GenFdsGlobalVariable: if not Inf.IsBinaryModule: for File in Inf.Sources: - if File.TagName in ("", "*", GenFdsGlobalVariable.ToolChainTag) and \ - File.ToolChainFamily in ("", "*", GenFdsGlobalVariable.ToolChainFamily): + if File.TagName in {"", "*", GenFdsGlobalVariable.ToolChainTag} and \ + File.ToolChainFamily in {"", "*", GenFdsGlobalVariable.ToolChainFamily}: FileList.append((File, DataType.TAB_UNKNOWN_FILE)) for File in Inf.Binaries: - if File.Target in [DataType.TAB_COMMON, '*', GenFdsGlobalVariable.TargetName]: + if File.Target in {DataType.TAB_COMMON, '*', GenFdsGlobalVariable.TargetName}: FileList.append((File, File.Type)) for File, FileType in FileList: @@ -233,7 +234,7 @@ class GenFdsGlobalVariable: Source = SourceList[Index] Index = Index + 1 - if File.IsBinary and File == Source and Inf.Binaries is not None and File in Inf.Binaries: + if File.IsBinary and File == Source and Inf.Binaries and File in Inf.Binaries: # Skip all files that are not binary libraries if not Inf.LibraryClass: continue @@ -287,19 +288,18 @@ class GenFdsGlobalVariable: # @param Workspace The directory of workspace # @param ArchList The Arch list of platform # + @staticmethod def SetDir (OutputDir, FdfParser, WorkSpace, ArchList): - GenFdsGlobalVariable.VerboseLogger("GenFdsGlobalVariable.OutputDir :%s" % OutputDir) -# GenFdsGlobalVariable.OutputDirDict = OutputDir + GenFdsGlobalVariable.VerboseLogger("GenFdsGlobalVariable.OutputDir:%s" % OutputDir) GenFdsGlobalVariable.FdfParser = FdfParser GenFdsGlobalVariable.WorkSpace = WorkSpace GenFdsGlobalVariable.FvDir = os.path.join(GenFdsGlobalVariable.OutputDirDict[ArchList[0]], DataType.TAB_FV_DIRECTORY) - if not os.path.exists(GenFdsGlobalVariable.FvDir) : + if not os.path.exists(GenFdsGlobalVariable.FvDir): os.makedirs(GenFdsGlobalVariable.FvDir) GenFdsGlobalVariable.FfsDir = os.path.join(GenFdsGlobalVariable.FvDir, 'Ffs') - if not os.path.exists(GenFdsGlobalVariable.FfsDir) : + if not os.path.exists(GenFdsGlobalVariable.FfsDir): os.makedirs(GenFdsGlobalVariable.FfsDir) - T_CHAR_LF = '\n' # # Create FV Address inf file # @@ -308,7 +308,7 @@ class GenFdsGlobalVariable: # # Add [Options] # - FvAddressFile.writelines("[options]" + T_CHAR_LF) + FvAddressFile.writelines("[options]" + DataType.TAB_LINE_BREAK) BsAddress = '0' for Arch in ArchList: if GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag].BsBaseAddress: @@ -317,19 +317,22 @@ class GenFdsGlobalVariable: FvAddressFile.writelines("EFI_BOOT_DRIVER_BASE_ADDRESS = " + \ BsAddress + \ - T_CHAR_LF) + DataType.TAB_LINE_BREAK) RtAddress = '0' - for Arch in ArchList: - if GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag].RtBaseAddress: - RtAddress = GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag].RtBaseAddress + for Arch in reversed(ArchList): + temp = GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag].RtBaseAddress + if temp: + RtAddress = temp + break FvAddressFile.writelines("EFI_RUNTIME_DRIVER_BASE_ADDRESS = " + \ RtAddress + \ - T_CHAR_LF) + DataType.TAB_LINE_BREAK) FvAddressFile.close() + @staticmethod def SetEnv(FdfParser, WorkSpace, ArchList, GlobalData): GenFdsGlobalVariable.ModuleFile = WorkSpace.ModuleFile GenFdsGlobalVariable.FdfParser = FdfParser @@ -360,7 +363,6 @@ class GenFdsGlobalVariable: if not os.path.exists(GenFdsGlobalVariable.FfsDir): os.makedirs(GenFdsGlobalVariable.FfsDir) - T_CHAR_LF = '\n' # # Create FV Address inf file # @@ -369,7 +371,7 @@ class GenFdsGlobalVariable: # # Add [Options] # - FvAddressFile.writelines("[options]" + T_CHAR_LF) + FvAddressFile.writelines("[options]" + DataType.TAB_LINE_BREAK) BsAddress = '0' for Arch in ArchList: BsAddress = GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, @@ -380,20 +382,20 @@ class GenFdsGlobalVariable: FvAddressFile.writelines("EFI_BOOT_DRIVER_BASE_ADDRESS = " + \ BsAddress + \ - T_CHAR_LF) + DataType.TAB_LINE_BREAK) RtAddress = '0' - for Arch in ArchList: - if GenFdsGlobalVariable.WorkSpace.BuildObject[ + for Arch in reversed(ArchList): + temp = GenFdsGlobalVariable.WorkSpace.BuildObject[ GenFdsGlobalVariable.ActivePlatform, Arch, GlobalData.gGlobalDefines['TARGET'], - GlobalData.gGlobalDefines["TOOL_CHAIN_TAG"]].RtBaseAddress: - RtAddress = GenFdsGlobalVariable.WorkSpace.BuildObject[ - GenFdsGlobalVariable.ActivePlatform, Arch, GlobalData.gGlobalDefines['TARGET'], - GlobalData.gGlobalDefines["TOOL_CHAIN_TAG"]].RtBaseAddress + GlobalData.gGlobalDefines["TOOL_CHAIN_TAG"]].RtBaseAddress + if temp: + RtAddress = temp + break FvAddressFile.writelines("EFI_RUNTIME_DRIVER_BASE_ADDRESS = " + \ RtAddress + \ - T_CHAR_LF) + DataType.TAB_LINE_BREAK) FvAddressFile.close() @@ -401,6 +403,7 @@ class GenFdsGlobalVariable: # # @param String String that may contain macro # + @staticmethod def ReplaceWorkspaceMacro(String): String = mws.handleWsMacro(String) Str = String.replace('$(WORKSPACE)', GenFdsGlobalVariable.WorkSpaceDir) @@ -424,7 +427,7 @@ class GenFdsGlobalVariable: if not os.path.exists(Output): return True # always update "Output" if no "Input" given - if Input is None or len(Input) == 0: + if not Input: return True # if fdf file is changed after the 'Output" is generated, update the 'Output' @@ -449,9 +452,9 @@ class GenFdsGlobalVariable: Cmd += ("-s", Type) if CompressionType: Cmd += ("-c", CompressionType) - if Guid is not None: + if Guid: Cmd += ("-g", Guid) - if DummyFile is not None: + if DummyFile: Cmd += ("--dummy", DummyFile) if GuidHdrLen: Cmd += ("-l", GuidHdrLen) @@ -473,7 +476,7 @@ class GenFdsGlobalVariable: if ' '.join(Cmd).strip() not in GenFdsGlobalVariable.SecCmdList: GenFdsGlobalVariable.SecCmdList.append(' '.join(Cmd).strip()) else: - SectionData = array.array('B', [0, 0, 0, 0]) + SectionData = array('B', [0, 0, 0, 0]) SectionData.fromstring(Ui.encode("utf_16_le")) SectionData.append(0) SectionData.append(0) @@ -571,9 +574,9 @@ class GenFdsGlobalVariable: if BaseAddress: Cmd += ("-r", BaseAddress) - if ForceRebase == False: + if not ForceRebase: Cmd += ("-F", "FALSE") - elif ForceRebase == True: + else: Cmd += ("-F", "TRUE") if Capsule: @@ -634,7 +637,7 @@ class GenFdsGlobalVariable: Revision=None, DeviceId=None, VendorId=None, IsMakefile=False): InputList = [] Cmd = ["EfiRom"] - if len(EfiInput) > 0: + if EfiInput: if Compress: Cmd.append("-ec") @@ -645,7 +648,7 @@ class GenFdsGlobalVariable: Cmd.append(EfiFile) InputList.append (EfiFile) - if len(BinaryInput) > 0: + if BinaryInput: Cmd.append("-b") for BinFile in BinaryInput: Cmd.append(BinFile) @@ -656,13 +659,13 @@ class GenFdsGlobalVariable: return GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, InputList)) - if ClassCode is not None: + if ClassCode: Cmd += ("-l", ClassCode) - if Revision is not None: + if Revision: Cmd += ("-r", Revision) - if DeviceId is not None: + if DeviceId: Cmd += ("-i", DeviceId) - if VendorId is not None: + if VendorId: Cmd += ("-f", VendorId) Cmd += ("-o", Output) @@ -688,6 +691,7 @@ class GenFdsGlobalVariable: else: GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to call " + ToolPath, returnValue) + @staticmethod def CallExternalTool (cmd, errorMess, returnValue=[]): if type(cmd) not in (tuple, list): @@ -701,19 +705,19 @@ class GenFdsGlobalVariable: cmd += ('-v',) GenFdsGlobalVariable.InfLogger (cmd) else: - sys.stdout.write ('#') - sys.stdout.flush() + stdout.write ('#') + stdout.flush() GenFdsGlobalVariable.SharpCounter = GenFdsGlobalVariable.SharpCounter + 1 if GenFdsGlobalVariable.SharpCounter % GenFdsGlobalVariable.SharpNumberPerLine == 0: - sys.stdout.write('\n') + stdout.write('\n') try: - PopenObject = subprocess.Popen(' '.join(cmd), stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True) + PopenObject = Popen(' '.join(cmd), stdout=PIPE, stderr=PIPE, shell=True) except Exception as X: EdkLogger.error("GenFds", COMMAND_FAILURE, ExtraData="%s: %s" % (str(X), cmd[0])) (out, error) = PopenObject.communicate() - while PopenObject.returncode is None : + while PopenObject.returncode is None: PopenObject.wait() if returnValue != [] and returnValue[0] != 0: #get command return value @@ -727,45 +731,52 @@ class GenFdsGlobalVariable: print("###", cmd) EdkLogger.error("GenFds", COMMAND_FAILURE, errorMess) + @staticmethod def VerboseLogger (msg): EdkLogger.verbose(msg) + @staticmethod def InfLogger (msg): EdkLogger.info(msg) + @staticmethod def ErrorLogger (msg, File=None, Line=None, ExtraData=None): EdkLogger.error('GenFds', GENFDS_ERROR, msg, File, Line, ExtraData) + @staticmethod def DebugLogger (Level, msg): EdkLogger.debug(Level, msg) - ## ReplaceWorkspaceMacro() + ## MacroExtend() # # @param Str String that may contain macro # @param MacroDict Dictionary that contains macro value pair # + @staticmethod def MacroExtend (Str, MacroDict={}, Arch=DataType.TAB_COMMON): - if Str is None : + if Str is None: return None - Dict = {'$(WORKSPACE)' : GenFdsGlobalVariable.WorkSpaceDir, - '$(EDK_SOURCE)' : GenFdsGlobalVariable.EdkSourceDir, + Dict = {'$(WORKSPACE)': GenFdsGlobalVariable.WorkSpaceDir, + '$(EDK_SOURCE)': GenFdsGlobalVariable.EdkSourceDir, # '$(OUTPUT_DIRECTORY)': GenFdsGlobalVariable.OutputDirFromDsc, - '$(TARGET)' : GenFdsGlobalVariable.TargetName, - '$(TOOL_CHAIN_TAG)' : GenFdsGlobalVariable.ToolChainTag, - '$(SPACE)' : ' ' + '$(TARGET)': GenFdsGlobalVariable.TargetName, + '$(TOOL_CHAIN_TAG)': GenFdsGlobalVariable.ToolChainTag, + '$(SPACE)': ' ' } - OutputDir = GenFdsGlobalVariable.OutputDirFromDscDict[GenFdsGlobalVariable.ArchList[0]] + if Arch != DataType.TAB_COMMON and Arch in GenFdsGlobalVariable.ArchList: OutputDir = GenFdsGlobalVariable.OutputDirFromDscDict[Arch] + else: + OutputDir = GenFdsGlobalVariable.OutputDirFromDscDict[GenFdsGlobalVariable.ArchList[0]] Dict['$(OUTPUT_DIRECTORY)'] = OutputDir - if MacroDict is not None and len (MacroDict) != 0: + if MacroDict: Dict.update(MacroDict) for key in Dict: - if Str.find(key) >= 0 : + if Str.find(key) >= 0: Str = Str.replace (key, Dict[key]) if Str.find('$(ARCH)') >= 0: @@ -780,14 +791,14 @@ class GenFdsGlobalVariable: # # @param PcdPattern pattern that labels a PCD. # + @staticmethod def GetPcdValue (PcdPattern): - if PcdPattern is None : + if PcdPattern is None: return None PcdPair = PcdPattern.lstrip('PCD(').rstrip(')').strip().split('.') TokenSpace = PcdPair[0] TokenCName = PcdPair[1] - PcdValue = '' for Arch in GenFdsGlobalVariable.ArchList: Platform = GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag] PcdDict = Platform.Pcds @@ -799,8 +810,7 @@ class GenFdsGlobalVariable: if PcdObj.DatumType != DataType.TAB_VOID: EdkLogger.error("GenFds", GENFDS_ERROR, "%s is not VOID* datum type." % PcdPattern) - PcdValue = PcdObj.DefaultValue - return PcdValue + return PcdObj.DefaultValue for Package in GenFdsGlobalVariable.WorkSpace.GetPackageList(GenFdsGlobalVariable.ActivePlatform, Arch, @@ -815,21 +825,9 @@ class GenFdsGlobalVariable: if PcdObj.DatumType != DataType.TAB_VOID: EdkLogger.error("GenFds", GENFDS_ERROR, "%s is not VOID* datum type." % PcdPattern) - PcdValue = PcdObj.DefaultValue - return PcdValue + return PcdObj.DefaultValue - return PcdValue - - SetDir = staticmethod(SetDir) - SetEnv = staticmethod(SetEnv) - ReplaceWorkspaceMacro = staticmethod(ReplaceWorkspaceMacro) - CallExternalTool = staticmethod(CallExternalTool) - VerboseLogger = staticmethod(VerboseLogger) - InfLogger = staticmethod(InfLogger) - ErrorLogger = staticmethod(ErrorLogger) - DebugLogger = staticmethod(DebugLogger) - MacroExtend = staticmethod (MacroExtend) - GetPcdValue = staticmethod(GetPcdValue) + return '' ## FindExtendTool() # @@ -863,7 +861,7 @@ def FindExtendTool(KeyStringList, CurrentArchList, NameGuid): ToolOptionKey = None KeyList = None for ToolDef in ToolDefinition.items(): - if NameGuid.lower() == ToolDef[1].lower() : + if NameGuid.lower() == ToolDef[1].lower(): KeyList = ToolDef[0].split('_') Key = KeyList[0] + \ '_' + \ diff --git a/BaseTools/Source/Python/GenFds/GuidSection.py b/BaseTools/Source/Python/GenFds/GuidSection.py index fd660737f4..25609e6f2a 100644 --- a/BaseTools/Source/Python/GenFds/GuidSection.py +++ b/BaseTools/Source/Python/GenFds/GuidSection.py @@ -19,7 +19,7 @@ from __future__ import absolute_import from . import Section import subprocess -from .Ffs import Ffs +from .Ffs import SectionSuffix import Common.LongFilePathOs as os from .GenFdsGlobalVariable import GenFdsGlobalVariable from .GenFdsGlobalVariable import FindExtendTool @@ -126,7 +126,7 @@ class GuidSection(GuidSectionClassObject) : ModuleName + \ SUP_MODULE_SEC + \ SecNum + \ - Ffs.SectionSuffix['GUIDED'] + SectionSuffix['GUIDED'] OutputFile = os.path.normpath(OutputFile) ExternalTool = None diff --git a/BaseTools/Source/Python/GenFds/OptionRom.py b/BaseTools/Source/Python/GenFds/OptionRom.py index bb7071fa7f..9d7ad25ecc 100644 --- a/BaseTools/Source/Python/GenFds/OptionRom.py +++ b/BaseTools/Source/Python/GenFds/OptionRom.py @@ -26,8 +26,6 @@ from Common.Misc import SaveFileOnChange from Common import EdkLogger from Common.BuildToolError import * -T_CHAR_LF = '\n' - ## # # @@ -36,9 +34,9 @@ class OPTIONROM (OptionRomClassObject): # # @param self The object pointer # - def __init__(self): + def __init__(self, Name = ""): OptionRomClassObject.__init__(self) - + self.DriverName = Name ## AddToBuffer() # diff --git a/BaseTools/Source/Python/GenFds/Region.py b/BaseTools/Source/Python/GenFds/Region.py index 5242b74c9e..9aeaa45d45 100644 --- a/BaseTools/Source/Python/GenFds/Region.py +++ b/BaseTools/Source/Python/GenFds/Region.py @@ -20,7 +20,6 @@ from struct import * from .GenFdsGlobalVariable import GenFdsGlobalVariable from io import BytesIO import string -from CommonDataClass.FdfClass import RegionClassObject import Common.LongFilePathOs as os from stat import * from Common import EdkLogger @@ -32,15 +31,20 @@ from Common.DataType import BINARY_FILE_TYPE_FV ## generate Region # # -class Region(RegionClassObject): +class Region(object): ## The constructor # # @param self The object pointer # def __init__(self): - RegionClassObject.__init__(self) - + self.Offset = None # The begin position of the Region + self.Size = None # The Size of the Region + self.PcdOffset = None + self.PcdSize = None + self.SetVarDict = {} + self.RegionType = None + self.RegionDataList = [] ## PadBuffer() # diff --git a/BaseTools/Source/Python/GenFds/UiSection.py b/BaseTools/Source/Python/GenFds/UiSection.py index 24f2f3ca93..c1dff188be 100644 --- a/BaseTools/Source/Python/GenFds/UiSection.py +++ b/BaseTools/Source/Python/GenFds/UiSection.py @@ -17,7 +17,7 @@ # from __future__ import absolute_import from . import Section -from .Ffs import Ffs +from .Ffs import SectionSuffix import subprocess import Common.LongFilePathOs as os from .GenFdsGlobalVariable import GenFdsGlobalVariable @@ -59,7 +59,7 @@ class UiSection (UiSectionClassObject): self.StringData = FfsInf.__ExtendMacro__(self.StringData) self.FileName = FfsInf.__ExtendMacro__(self.FileName) - OutputFile = os.path.join(OutputPath, ModuleName + SUP_MODULE_SEC + SecNum + Ffs.SectionSuffix.get(BINARY_FILE_TYPE_UI)) + OutputFile = os.path.join(OutputPath, ModuleName + SUP_MODULE_SEC + SecNum + SectionSuffix.get(BINARY_FILE_TYPE_UI)) if self.StringData is not None : NameString = self.StringData diff --git a/BaseTools/Source/Python/GenFds/VerSection.py b/BaseTools/Source/Python/GenFds/VerSection.py index db71fe9653..051743f10c 100644 --- a/BaseTools/Source/Python/GenFds/VerSection.py +++ b/BaseTools/Source/Python/GenFds/VerSection.py @@ -1,7 +1,7 @@ ## @file # process Version section generation # -# Copyright (c) 2007 - 2017, Intel Corporation. All rights reserved.
+# Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.
# # This program and the accompanying materials # are licensed and made available under the terms and conditions of the BSD License @@ -16,10 +16,8 @@ # Import Modules # from __future__ import absolute_import -from .Ffs import Ffs -from . import Section +from .Ffs import SectionSuffix import Common.LongFilePathOs as os -import subprocess from .GenFdsGlobalVariable import GenFdsGlobalVariable from CommonDataClass.FdfClass import VerSectionClassObject from Common.LongFilePathSupport import OpenLongFilePath as open @@ -54,29 +52,27 @@ class VerSection (VerSectionClassObject): # # Prepare the parameter of GenSection # - if FfsInf is not None: + if FfsInf: self.Alignment = FfsInf.__ExtendMacro__(self.Alignment) self.BuildNum = FfsInf.__ExtendMacro__(self.BuildNum) self.StringData = FfsInf.__ExtendMacro__(self.StringData) self.FileName = FfsInf.__ExtendMacro__(self.FileName) OutputFile = os.path.join(OutputPath, - ModuleName + SUP_MODULE_SEC + SecNum + Ffs.SectionSuffix.get('VERSION')) + ModuleName + SUP_MODULE_SEC + SecNum + SectionSuffix.get('VERSION')) OutputFile = os.path.normpath(OutputFile) # Get String Data StringData = '' - if self.StringData is not None: + if self.StringData: StringData = self.StringData - elif self.FileName is not None: + elif self.FileName: FileNameStr = GenFdsGlobalVariable.ReplaceWorkspaceMacro(self.FileName) FileNameStr = GenFdsGlobalVariable.MacroExtend(FileNameStr, Dict) FileObj = open(FileNameStr, 'r') StringData = FileObj.read() StringData = '"' + StringData + '"' FileObj.close() - else: - StringData = '' GenFdsGlobalVariable.GenerateSection(OutputFile, [], 'EFI_SECTION_VERSION', Ver=StringData, BuildNumber=self.BuildNum, IsMakefile=IsMakefile) OutputFileList = [] diff --git a/BaseTools/Source/Python/GenFds/Vtf.py b/BaseTools/Source/Python/GenFds/Vtf.py index 5cb2d4acfb..9dcd48b2d8 100644 --- a/BaseTools/Source/Python/GenFds/Vtf.py +++ b/BaseTools/Source/Python/GenFds/Vtf.py @@ -18,21 +18,24 @@ from __future__ import absolute_import from .GenFdsGlobalVariable import GenFdsGlobalVariable import Common.LongFilePathOs as os -from CommonDataClass.FdfClass import VtfClassObject from Common.LongFilePathSupport import OpenLongFilePath as open -T_CHAR_LF = '\n' +from Common.DataType import TAB_LINE_BREAK ## generate VTF # # -class Vtf (VtfClassObject): +class Vtf (object): ## The constructor # # @param self The object pointer # def __init__(self): - VtfClassObject.__init__(self) + self.KeyArch = None + self.ArchList = None + self.UiName = None + self.ResetBin = None + self.ComponentStatementList = [] ## GenVtf() method # @@ -44,7 +47,6 @@ class Vtf (VtfClassObject): # def GenVtf(self, FdAddressDict) : self.GenBsfInf() - OutputFile = os.path.join(GenFdsGlobalVariable.FvDir, self.UiName + '.Vtf') BaseAddArg = self.GetBaseAddressArg(FdAddressDict) OutputArg, VtfRawDict = self.GenOutputArg() @@ -69,57 +71,57 @@ class Vtf (VtfClassObject): FvList = self.GetFvList() self.BsfInfName = os.path.join(GenFdsGlobalVariable.FvDir, self.UiName + '.inf') BsfInf = open(self.BsfInfName, 'w+') - if self.ResetBin is not None: - BsfInf.writelines ("[OPTIONS]" + T_CHAR_LF) + if self.ResetBin: + BsfInf.writelines ("[OPTIONS]" + TAB_LINE_BREAK) BsfInf.writelines ("IA32_RST_BIN" + \ " = " + \ GenFdsGlobalVariable.MacroExtend(GenFdsGlobalVariable.ReplaceWorkspaceMacro(self.ResetBin)) + \ - T_CHAR_LF) - BsfInf.writelines (T_CHAR_LF) + TAB_LINE_BREAK) + BsfInf.writelines (TAB_LINE_BREAK) - BsfInf.writelines ("[COMPONENTS]" + T_CHAR_LF) + BsfInf.writelines ("[COMPONENTS]" + TAB_LINE_BREAK) for ComponentObj in self.ComponentStatementList : BsfInf.writelines ("COMP_NAME" + \ " = " + \ ComponentObj.CompName + \ - T_CHAR_LF) + TAB_LINE_BREAK) if ComponentObj.CompLoc.upper() == 'NONE': BsfInf.writelines ("COMP_LOC" + \ " = " + \ 'N' + \ - T_CHAR_LF) + TAB_LINE_BREAK) - elif ComponentObj.FilePos is not None: + elif ComponentObj.FilePos: BsfInf.writelines ("COMP_LOC" + \ " = " + \ ComponentObj.FilePos + \ - T_CHAR_LF) + TAB_LINE_BREAK) else: Index = FvList.index(ComponentObj.CompLoc.upper()) if Index == 0: BsfInf.writelines ("COMP_LOC" + \ " = " + \ 'F' + \ - T_CHAR_LF) + TAB_LINE_BREAK) elif Index == 1: BsfInf.writelines ("COMP_LOC" + \ " = " + \ 'S' + \ - T_CHAR_LF) + TAB_LINE_BREAK) BsfInf.writelines ("COMP_TYPE" + \ " = " + \ ComponentObj.CompType + \ - T_CHAR_LF) + TAB_LINE_BREAK) BsfInf.writelines ("COMP_VER" + \ " = " + \ ComponentObj.CompVer + \ - T_CHAR_LF) + TAB_LINE_BREAK) BsfInf.writelines ("COMP_CS" + \ " = " + \ ComponentObj.CompCs + \ - T_CHAR_LF) + TAB_LINE_BREAK) BinPath = ComponentObj.CompBin if BinPath != '-': @@ -127,7 +129,7 @@ class Vtf (VtfClassObject): BsfInf.writelines ("COMP_BIN" + \ " = " + \ BinPath + \ - T_CHAR_LF) + TAB_LINE_BREAK) SymPath = ComponentObj.CompSym if SymPath != '-': @@ -135,12 +137,12 @@ class Vtf (VtfClassObject): BsfInf.writelines ("COMP_SYM" + \ " = " + \ SymPath + \ - T_CHAR_LF) + TAB_LINE_BREAK) BsfInf.writelines ("COMP_SIZE" + \ " = " + \ ComponentObj.CompSize + \ - T_CHAR_LF) - BsfInf.writelines (T_CHAR_LF) + TAB_LINE_BREAK) + BsfInf.writelines (TAB_LINE_BREAK) BsfInf.close() diff --git a/BaseTools/Source/Python/build/BuildReport.py b/BaseTools/Source/Python/build/BuildReport.py index ea98ef7ed5..d379866618 100644 --- a/BaseTools/Source/Python/build/BuildReport.py +++ b/BaseTools/Source/Python/build/BuildReport.py @@ -46,6 +46,7 @@ from Common.StringUtils import NormPath from Common.DataType import * import collections from Common.Expression import * +from GenFds.AprioriSection import DXE_APRIORI_GUID, PEI_APRIORI_GUID ## Pattern to extract contents in EDK DXS files gDxsDependencyPattern = re.compile(r"DEPENDENCY_START(.+)DEPENDENCY_END", re.DOTALL) @@ -1873,8 +1874,8 @@ class FdRegionReport(object): # # Add PEI and DXE a priori files GUIDs defined in PI specification. # - self._GuidsDb["1B45CC0A-156A-428A-AF62-49864DA0E6E6"] = "PEI Apriori" - self._GuidsDb["FC510EE7-FFDC-11D4-BD41-0080C73C8881"] = "DXE Apriori" + self._GuidsDb[PEI_APRIORI_GUID] = "PEI Apriori" + self._GuidsDb[DXE_APRIORI_GUID] = "DXE Apriori" # # Add ACPI table storage file #