From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received-SPF: Pass (sender SPF authorized) identity=mailfrom; client-ip=195.135.221.5; helo=smtp.nue.novell.com; envelope-from=glin@suse.com; receiver=edk2-devel@lists.01.org Received: from smtp.nue.novell.com (smtp.nue.novell.com [195.135.221.5]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ml01.01.org (Postfix) with ESMTPS id 97AFC2117B57A for ; Thu, 25 Oct 2018 23:55:31 -0700 (PDT) Received: from emea4-mta.ukb.novell.com ([10.120.13.87]) by smtp.nue.novell.com with ESMTP (TLS encrypted); Fri, 26 Oct 2018 08:55:29 +0200 Received: from GaryWorkstation (nwb-a10-snat.microfocus.com [10.120.13.201]) by emea4-mta.ukb.novell.com with ESMTP (TLS encrypted); Fri, 26 Oct 2018 07:55:00 +0100 Date: Fri, 26 Oct 2018 14:54:55 +0800 From: Gary Lin To: "Gao, Liming" Cc: "Carsey, Jaben" , "edk2-devel@lists.01.org" Message-ID: <20181026065455.GB18048@GaryWorkstation> References: <7064a2912d4507d29b00208fe7adb6a90b321e63.1540315635.git.jaben.carsey@intel.com> <20181026045359.GA18048@GaryWorkstation> <4A89E2EF3DFEDB4C8BFDE51014F606A14E35EFC0@SHSMSX104.ccr.corp.intel.com> <4A89E2EF3DFEDB4C8BFDE51014F606A14E35F146@SHSMSX104.ccr.corp.intel.com> MIME-Version: 1.0 In-Reply-To: <4A89E2EF3DFEDB4C8BFDE51014F606A14E35F146@SHSMSX104.ccr.corp.intel.com> User-Agent: Mutt/1.10.1 (2018-07-13) Subject: Re: [Patch v3 1/6] BaseTools/GenFds: cleanup GenFds X-BeenThere: edk2-devel@lists.01.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: EDK II Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Fri, 26 Oct 2018 06:55:33 -0000 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline On Fri, Oct 26, 2018 at 06:27:53AM +0000, Gao, Liming wrote: > Edk2 599bb2be1f2b119dcde9e5a7515dc6f3d19eb29d has fixed this issue. Please try. I rebuilt OVMF with git HEAD, and the crash was gone. Thanks! Gary Lin > > > -----Original Message----- > > From: edk2-devel [mailto:edk2-devel-bounces@lists.01.org] On Behalf Of Gao, Liming > > Sent: Friday, October 26, 2018 1:25 PM > > To: Gary Lin ; Carsey, Jaben > > Cc: edk2-devel@lists.01.org > > Subject: Re: [edk2] [Patch v3 1/6] BaseTools/GenFds: cleanup GenFds > > > > Lin: > > I am checking this issue. Sorry for the break. > > > > Thanks > > Liming > > > -----Original Message----- > > > From: Gary Lin [mailto:glin@suse.com] > > > Sent: Friday, October 26, 2018 12:54 PM > > > To: Carsey, Jaben > > > Cc: edk2-devel@lists.01.org; Gao, Liming > > > Subject: Re: [edk2] [Patch v3 1/6] BaseTools/GenFds: cleanup GenFds > > > > > > On Tue, Oct 23, 2018 at 10:29:19AM -0700, Jaben Carsey wrote: > > > > 1) remove wildcard imports and use explicit imports > > > > 2) refactor to use shared variables from Common/DataType > > > > 3) rename to not shadow imports > > > > 4) don't assign a variable in a loop (just do final assignment) > > > > 5) remove spaces, parens, unused or commented out code, etc. > > > > 6) merge unnecessary parent classes into child > > > > 7) refactor to share DXE and PEI apriori GUIDs from one place > > > > this includes changes to Build and EOT files > > > > 8) for PEP8, dont use __ for custom methods. > > > > > > > Hi Jaben, > > > > > > I found OVMF crashed immediately at starting up after applying this patch :-\ > > > > > > == > > > > > > $ qemu-system-x86_64 -s -enable-kvm -smp 1 -m 1024 \ > > > -drive if=pflash,format=raw,readonly,file=/home/gary/git/edk2/Build/OvmfX64/DEBUG_GCC5/FV/OVMF_CODE.fd \ > > > -drive if=pflash,format=raw,file=/home/gary/git/edk2/Build/OvmfX64/DEBUG_GCC5/FV/OVMF_VARS.fd \ > > > -machine type=q35 \ > > > -drive file=fat:hda-contents/,format=raw,read-only,if=virtio \ > > > -monitor stdio -debugcon file:debug.log -global isa-debugcon.iobase=0x402 \ > > > -serial file:serial.log > > > QEMU 3.0.0 monitor - type 'help' for more information > > > (qemu) KVM internal error. Suberror: 1 > > > emulation failure > > > RAX=000000000081f6a0 RBX=0000000000000200 RCX=000000000081f6a0 RDX=0000000000000200 > > > RSI=000000000081f698 RDI=000000000081fd20 RBP=000000000081f698 RSP=000000000081f4a8 > > > R8 =000000000081f4d8 R9 =000000000081f748 R10=0000000000000010 R11=0000000000900000 > > > R12=0000000000000000 R13=0000000000820000 R14=000000000081fd01 R15=000000000081fd01 > > > RIP=000000000009ffff RFL=00010807 [-O---PC] CPL=0 II=0 A20=1 SMM=0 HLT=0 > > > ES =0008 0000000000000000 ffffffff 00c09300 DPL=0 DS [-WA] > > > CS =0018 0000000000000000 ffffffff 00a09b00 DPL=0 CS64 [-RA] > > > SS =0008 0000000000000000 ffffffff 00c09300 DPL=0 DS [-WA] > > > DS =0008 0000000000000000 ffffffff 00c09300 DPL=0 DS [-WA] > > > FS =0008 0000000000000000 ffffffff 00c09300 DPL=0 DS [-WA] > > > GS =0008 0000000000000000 ffffffff 00c09300 DPL=0 DS [-WA] > > > LDT=0000 0000000000000000 0000ffff 00008200 DPL=0 LDT > > > TR =0000 0000000000000000 0000ffff 00008b00 DPL=0 TSS64-busy > > > GDT= 00000000ffffff80 0000001f > > > IDT= 000000000081fd70 0000021f > > > CR0=c0000033 CR2=0000000000000000 CR3=0000000000800000 CR4=00000660 > > > DR0=0000000000000000 DR1=0000000000000000 DR2=0000000000000000 DR3=0000000000000000 > > > DR6=00000000ffff0ff0 DR7=0000000000000400 > > > EFER=0000000000000500 > > > Code=00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 <00> 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 > > > 00 00 00 00 00 00 00 00 00 > > > > > > == > > > > > > And, there is only one line in debug.log: > > > > > > SecCoreStartupWithStack(0xFFFCC000, 0x820000) > > > > > > Without "-enable-kvm", the error became: > > > > > > == > > > > > > (qemu) qemu-system-x86_64: Trying to execute code outside RAM or ROM at 0x00000000000a0000 > > > This usually means one of the following happened: > > > > > > (1) You told QEMU to execute a kernel for the wrong machine type, and it crashed on startup (eg trying to run a raspberry pi kernel on > > a > > > versatilepb QEMU machine) > > > (2) You didn't give QEMU a kernel or BIOS filename at all, and QEMU executed a ROM full of no-op instructions until it fell off the end > > > (3) Your guest kernel has a bug and crashed by jumping off into nowhere > > > > > > This is almost always one of the first two, so check your command line and that you are using the right type of kernel for this machine. > > > If you think option (3) is likely then you can try debugging your guest with the -d debug options; in particular -d guest_errors will cause > > > the log to include a dump of the guest register state at this point. > > > > > > Execution cannot continue; stopping here. > > > > > > == > > > > > > Gary Lin > > > > > > > Cc: Yonghong Zhu > > > > Cc: Liming Gao > > > > Cc: Bob C Feng > > > > Contributed-under: TianoCore Contribution Agreement 1.1 > > > > Signed-off-by: Jaben Carsey > > > > --- > > > > BaseTools/Source/Python/CommonDataClass/FdfClass.py | 73 - > > > > BaseTools/Source/Python/Eot/EotMain.py | 372 ++- > > > > BaseTools/Source/Python/GenFds/AprioriSection.py | 45 +- > > > > BaseTools/Source/Python/GenFds/Capsule.py | 26 +- > > > > BaseTools/Source/Python/GenFds/CapsuleData.py | 1 - > > > > BaseTools/Source/Python/GenFds/CompressSection.py | 4 +- > > > > BaseTools/Source/Python/GenFds/DataSection.py | 4 +- > > > > BaseTools/Source/Python/GenFds/DepexSection.py | 5 +- > > > > BaseTools/Source/Python/GenFds/EfiSection.py | 16 +- > > > > BaseTools/Source/Python/GenFds/FdfParser.py | 3014 ++++++++++---------- > > > > BaseTools/Source/Python/GenFds/Ffs.py | 82 +- > > > > BaseTools/Source/Python/GenFds/FfsFileStatement.py | 37 +- > > > > BaseTools/Source/Python/GenFds/FfsInfStatement.py | 10 +- > > > > BaseTools/Source/Python/GenFds/Fv.py | 47 +- > > > > BaseTools/Source/Python/GenFds/FvImageSection.py | 6 +- > > > > BaseTools/Source/Python/GenFds/GenFds.py | 160 +- > > > > BaseTools/Source/Python/GenFds/GenFdsGlobalVariable.py | 208 +- > > > > BaseTools/Source/Python/GenFds/GuidSection.py | 4 +- > > > > BaseTools/Source/Python/GenFds/OptionRom.py | 6 +- > > > > BaseTools/Source/Python/GenFds/Region.py | 12 +- > > > > BaseTools/Source/Python/GenFds/UiSection.py | 4 +- > > > > BaseTools/Source/Python/GenFds/VerSection.py | 16 +- > > > > BaseTools/Source/Python/GenFds/Vtf.py | 48 +- > > > > BaseTools/Source/Python/build/BuildReport.py | 5 +- > > > > 24 files changed, 2185 insertions(+), 2020 deletions(-) > > > > > > > > diff --git a/BaseTools/Source/Python/CommonDataClass/FdfClass.py b/BaseTools/Source/Python/CommonDataClass/FdfClass.py > > > > index 64b58c2078a3..3df82082457f 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 49a1494126c4..2ad93cc6b4e3 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 7196f7f2c753..e7b856a1150a 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 baa6e1dfa2ab..df29c40dbd20 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 0caba8983d2e..6071e9f4a545 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 aaaabf84dca8..51f6791fab19 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 a6387b07c582..28f9b931ca4b 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 b2d123bfc045..78efc18816e8 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 623b77d27427..f8573b5c7d1b 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 63687e98bb31..62bf9f14012a 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 598b2d023124..4c1b43572964 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 4c35aac76a00..7479efff04c7 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 6149bc81b4ef..c1073c96e9aa 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 c66fc383278d..30525bd11fcc 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 04556fc87099..d6e1f3315b7e 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 9dec9c5eb57d..0c8091b79841 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 14578a92a9b1..e867693d7c88 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 > > > > +from __future__ import absolute_import > > > > + > > > > import Common.LongFilePathOs as os > > > > -import sys > > > > -import subprocess > > > > -import struct > > > > -import array > > > > +from sys import stdout > > > > +from subprocess import PIPE,Popen > > > > +from struct import Struct > > > > +from array import array > > > > > > > > -from Common.BuildToolError import * > > > > +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 fd660737f421..25609e6f2ae1 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 bb7071fa7fca..9d7ad25ecc43 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 5242b74c9e70..9aeaa45d4566 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 24f2f3ca938d..c1dff188be96 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 db71fe9653d4..051743f10c21 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 5cb2d4acfb1c..9dcd48b2d812 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 a66adfb16746..95863fefe151 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) > > > > @@ -1853,8 +1854,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 > > > > # > > > > -- > > > > 2.16.2.windows.1 > > > > > > > > _______________________________________________ > > > > edk2-devel mailing list > > > > edk2-devel@lists.01.org > > > > https://lists.01.org/mailman/listinfo/edk2-devel > > > > > > _______________________________________________ > > edk2-devel mailing list > > edk2-devel@lists.01.org > > https://lists.01.org/mailman/listinfo/edk2-devel > _______________________________________________ > edk2-devel mailing list > edk2-devel@lists.01.org > https://lists.01.org/mailman/listinfo/edk2-devel >