mirror of
https://github.com/acidanthera/audk.git
synced 2025-04-08 17:05:09 +02:00
d35773d5c0
REF: https://bugzilla.tianocore.org/show_bug.cgi?id=2762 The Fv Section in the FDF files use hard coding Guid values which is inconvenient to manage. This patch adds Guid name support in GenFfs to solve this problem. Signed-off-by: Yuwei Chen <yuwei.chen@intel.com> Reviewed-by: Bob Feng<bob.c.feng@intel.com>
4529 lines
190 KiB
Python
4529 lines
190 KiB
Python
## @file
|
|
# parse FDF file
|
|
#
|
|
# Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>
|
|
# Copyright (c) 2015, Hewlett Packard Enterprise Development, L.P.<BR>
|
|
#
|
|
# SPDX-License-Identifier: BSD-2-Clause-Patent
|
|
#
|
|
|
|
##
|
|
# Import Modules
|
|
#
|
|
from __future__ import print_function
|
|
from __future__ import absolute_import
|
|
from re import compile, DOTALL
|
|
from string import hexdigits
|
|
from uuid import UUID
|
|
|
|
from Common.BuildToolError import *
|
|
from Common import EdkLogger
|
|
from Common.Misc import PathClass, tdict, ProcessDuplicatedInf, GuidStructureStringToGuidString
|
|
from Common.StringUtils import NormPath, ReplaceMacro
|
|
from Common import GlobalData
|
|
from Common.Expression import *
|
|
from Common.DataType import *
|
|
from Common.MultipleWorkspace import MultipleWorkspace as mws
|
|
import Common.LongFilePathOs as os
|
|
from Common.LongFilePathSupport import OpenLongFilePath as open
|
|
from Common.RangeExpression import RangeExpression
|
|
from collections import OrderedDict
|
|
|
|
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 .OptionRom import OPTIONROM
|
|
from .OptRomInfStatement import OptRomInfStatement, OverrideAttribs
|
|
from .OptRomFileStatement import OptRomFileStatement
|
|
from .GenFdsGlobalVariable import GenFdsGlobalVariable
|
|
|
|
T_CHAR_CR = '\r'
|
|
T_CHAR_TAB = '\t'
|
|
T_CHAR_DOUBLE_QUOTE = '\"'
|
|
T_CHAR_SINGLE_QUOTE = '\''
|
|
T_CHAR_BRACE_R = '}'
|
|
|
|
SEPARATORS = {TAB_EQUAL_SPLIT, TAB_VALUE_SPLIT, TAB_COMMA_SPLIT, '{', T_CHAR_BRACE_R}
|
|
ALIGNMENTS = {"Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K", "64K", "128K",
|
|
"256K", "512K", "1M", "2M", "4M", "8M", "16M"}
|
|
ALIGNMENT_NOAUTO = ALIGNMENTS - {"Auto"}
|
|
CR_LB_SET = {T_CHAR_CR, TAB_LINE_BREAK}
|
|
|
|
RegionSizePattern = compile("\s*(?P<base>(?:0x|0X)?[a-fA-F0-9]+)\s*\|\s*(?P<size>(?:0x|0X)?[a-fA-F0-9]+)\s*")
|
|
RegionSizeGuidPattern = compile("\s*(?P<base>\w+\.\w+[\.\w\[\]]*)\s*\|\s*(?P<size>\w+\.\w+[\.\w\[\]]*)\s*")
|
|
RegionOffsetPcdPattern = compile("\s*(?P<base>\w+\.\w+[\.\w\[\]]*)\s*$")
|
|
ShortcutPcdPattern = compile("\s*\w+\s*=\s*(?P<value>(?:0x|0X)?[a-fA-F0-9]+)\s*\|\s*(?P<name>\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
|
|
def GetParentAtLine (Line):
|
|
for Profile in AllIncludeFileList:
|
|
if Profile.IsLineInFile(Line):
|
|
return Profile
|
|
return None
|
|
|
|
# Check include loop
|
|
def IsValidInclude (File, Line):
|
|
for Profile in AllIncludeFileList:
|
|
if Profile.IsLineInFile(Line) and Profile.FileName == File:
|
|
return False
|
|
|
|
return True
|
|
|
|
def GetRealFileLine (File, Line):
|
|
InsertedLines = 0
|
|
for Profile in AllIncludeFileList:
|
|
if Profile.IsLineInFile(Line):
|
|
return Profile.GetLineInFile(Line)
|
|
elif Line >= Profile.InsertStartLineNumber and Profile.Level == 1:
|
|
InsertedLines += Profile.GetTotalLines()
|
|
|
|
return (File, Line - InsertedLines)
|
|
|
|
## The exception class that used to report error messages when parsing FDF
|
|
#
|
|
# Currently the "ToolName" is set to be "FdfParser".
|
|
#
|
|
class Warning (Exception):
|
|
## The constructor
|
|
#
|
|
# @param self The object pointer
|
|
# @param Str The message to record
|
|
# @param File The FDF name
|
|
# @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]
|
|
self.OriginalLineNumber = Line
|
|
self.Message = Str
|
|
self.ToolName = 'FdfParser'
|
|
|
|
def __str__(self):
|
|
return self.Message
|
|
|
|
# helper functions to facilitate consistency in warnings
|
|
# each function is for a different common warning
|
|
@staticmethod
|
|
def Expected(Str, File, Line):
|
|
return Warning("expected {}".format(Str), File, Line)
|
|
@staticmethod
|
|
def ExpectedEquals(File, Line):
|
|
return Warning.Expected("'='", File, Line)
|
|
@staticmethod
|
|
def ExpectedCurlyOpen(File, Line):
|
|
return Warning.Expected("'{'", File, Line)
|
|
@staticmethod
|
|
def ExpectedCurlyClose(File, Line):
|
|
return Warning.Expected("'}'", File, Line)
|
|
@staticmethod
|
|
def ExpectedBracketClose(File, Line):
|
|
return Warning.Expected("']'", File, Line)
|
|
|
|
## The Include file content class that used to record file data when parsing include file
|
|
#
|
|
# May raise Exception when opening file.
|
|
#
|
|
class IncludeFileProfile:
|
|
## The constructor
|
|
#
|
|
# @param self The object pointer
|
|
# @param FileName The file that to be parsed
|
|
#
|
|
def __init__(self, FileName):
|
|
self.FileName = FileName
|
|
self.FileLinesList = []
|
|
try:
|
|
with open(FileName, "r") as fsock:
|
|
self.FileLinesList = fsock.readlines()
|
|
for index, line in enumerate(self.FileLinesList):
|
|
if not line.endswith(TAB_LINE_BREAK):
|
|
self.FileLinesList[index] += TAB_LINE_BREAK
|
|
except:
|
|
EdkLogger.error("FdfParser", FILE_OPEN_FAILURE, ExtraData=FileName)
|
|
|
|
self.InsertStartLineNumber = None
|
|
self.InsertAdjust = 0
|
|
self.IncludeFileList = []
|
|
self.Level = 1 # first level include file
|
|
|
|
def GetTotalLines(self):
|
|
TotalLines = self.InsertAdjust + len(self.FileLinesList)
|
|
|
|
for Profile in self.IncludeFileList:
|
|
TotalLines += Profile.GetTotalLines()
|
|
|
|
return TotalLines
|
|
|
|
def IsLineInFile(self, Line):
|
|
if Line >= self.InsertStartLineNumber and Line < self.InsertStartLineNumber + self.GetTotalLines():
|
|
return True
|
|
|
|
return False
|
|
|
|
def GetLineInFile(self, Line):
|
|
if not self.IsLineInFile (Line):
|
|
return (self.FileName, -1)
|
|
|
|
InsertedLines = self.InsertStartLineNumber
|
|
|
|
for Profile in self.IncludeFileList:
|
|
if Profile.IsLineInFile(Line):
|
|
return Profile.GetLineInFile(Line)
|
|
elif Line >= Profile.InsertStartLineNumber:
|
|
InsertedLines += Profile.GetTotalLines()
|
|
|
|
return (self.FileName, Line - InsertedLines + 1)
|
|
|
|
## The FDF content class that used to record file data when parsing FDF
|
|
#
|
|
# May raise Exception when opening file.
|
|
#
|
|
class FileProfile:
|
|
## The constructor
|
|
#
|
|
# @param self The object pointer
|
|
# @param FileName The file that to be parsed
|
|
#
|
|
def __init__(self, FileName):
|
|
self.FileLinesList = []
|
|
try:
|
|
with open(FileName, "r") as fsock:
|
|
self.FileLinesList = fsock.readlines()
|
|
|
|
except:
|
|
EdkLogger.error("FdfParser", FILE_OPEN_FAILURE, ExtraData=FileName)
|
|
|
|
self.FileName = FileName
|
|
self.PcdDict = OrderedDict()
|
|
self.PcdLocalDict = OrderedDict()
|
|
self.InfList = []
|
|
self.InfDict = {'ArchTBD':[]}
|
|
# ECC will use this Dict and List information
|
|
self.PcdFileLineDict = {}
|
|
self.InfFileLineList = []
|
|
|
|
self.FdDict = {}
|
|
self.FdNameNotSet = False
|
|
self.FvDict = {}
|
|
self.CapsuleDict = {}
|
|
self.RuleDict = {}
|
|
self.OptRomDict = {}
|
|
self.FmpPayloadDict = {}
|
|
|
|
## The syntax parser for FDF
|
|
#
|
|
# PreprocessFile method should be called prior to ParseFile
|
|
# CycleReferenceCheck method can detect cycles in FDF contents
|
|
#
|
|
# GetNext*** procedures mean these procedures will get next token first, then make judgement.
|
|
# Get*** procedures mean these procedures will make judgement on current token only.
|
|
#
|
|
class FdfParser:
|
|
## The constructor
|
|
#
|
|
# @param self The object pointer
|
|
# @param FileName The file that to be parsed
|
|
#
|
|
def __init__(self, FileName):
|
|
self.Profile = FileProfile(FileName)
|
|
self.FileName = FileName
|
|
self.CurrentLineNumber = 1
|
|
self.CurrentOffsetWithinLine = 0
|
|
self.CurrentFdName = None
|
|
self.CurrentFvName = None
|
|
self._Token = ""
|
|
self._SkippedChars = ""
|
|
GlobalData.gFdfParser = self
|
|
|
|
# Used to section info
|
|
self._CurSection = []
|
|
# Key: [section name, UI name, arch]
|
|
# Value: {MACRO_NAME: MACRO_VALUE}
|
|
self._MacroDict = tdict(True, 3)
|
|
self._PcdDict = OrderedDict()
|
|
|
|
self._WipeOffArea = []
|
|
if GenFdsGlobalVariable.WorkSpaceDir == '':
|
|
GenFdsGlobalVariable.WorkSpaceDir = os.getenv("WORKSPACE")
|
|
|
|
## _SkipWhiteSpace() method
|
|
#
|
|
# Skip white spaces from current char.
|
|
#
|
|
# @param self The object pointer
|
|
#
|
|
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:
|
|
return
|
|
return
|
|
|
|
## _EndOfFile() method
|
|
#
|
|
# Judge current buffer pos is at file end
|
|
#
|
|
# @param self The object pointer
|
|
# @retval True Current File buffer position is at file end
|
|
# @retval False Current File buffer position is NOT at file end
|
|
#
|
|
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
|
|
if self.CurrentLineNumber > NumberOfLines:
|
|
return True
|
|
return False
|
|
|
|
## _EndOfLine() method
|
|
#
|
|
# Judge current buffer pos is at line end
|
|
#
|
|
# @param self The object pointer
|
|
# @retval True Current File buffer position is at line end
|
|
# @retval False Current File buffer position is NOT at line end
|
|
#
|
|
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
|
|
return False
|
|
|
|
## Rewind() method
|
|
#
|
|
# Reset file data buffer to the initial state
|
|
#
|
|
# @param self The object pointer
|
|
# @param DestLine Optional new destination line number.
|
|
# @param DestOffset Optional new destination offset.
|
|
#
|
|
def Rewind(self, DestLine = 1, DestOffset = 0):
|
|
self.CurrentLineNumber = DestLine
|
|
self.CurrentOffsetWithinLine = DestOffset
|
|
|
|
## _UndoOneChar() method
|
|
#
|
|
# Go back one char in the file buffer
|
|
#
|
|
# @param self The object pointer
|
|
# @retval True Successfully go back one char
|
|
# @retval False Not able to go back one char as file beginning reached
|
|
#
|
|
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
|
|
else:
|
|
self.CurrentOffsetWithinLine -= 1
|
|
return True
|
|
|
|
## _GetOneChar() method
|
|
#
|
|
# Move forward one char in the file buffer
|
|
#
|
|
# @param self The object pointer
|
|
#
|
|
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
|
|
#
|
|
# Get the char pointed to by the file buffer pointer
|
|
#
|
|
# @param self The object pointer
|
|
# @retval Char Current char
|
|
#
|
|
def _CurrentChar(self):
|
|
return self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine]
|
|
|
|
## _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):
|
|
if self.CurrentOffsetWithinLine == len(self.Profile.FileLinesList[self.CurrentLineNumber - 1]) - 1:
|
|
return self.Profile.FileLinesList[self.CurrentLineNumber][0]
|
|
return self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine + 1]
|
|
|
|
## _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):
|
|
self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine] = Value
|
|
|
|
## _CurrentLine() method
|
|
#
|
|
# Get the list that contains current line contents
|
|
#
|
|
# @param self The object pointer
|
|
# @retval List current line contents
|
|
#
|
|
def _CurrentLine(self):
|
|
return self.Profile.FileLinesList[self.CurrentLineNumber - 1]
|
|
|
|
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 = ' '):
|
|
if StartPos[0] == EndPos[0]:
|
|
Offset = StartPos[1]
|
|
while Offset <= EndPos[1]:
|
|
self.Profile.FileLinesList[StartPos[0]][Offset] = Value
|
|
Offset += 1
|
|
return
|
|
|
|
Offset = StartPos[1]
|
|
while self.Profile.FileLinesList[StartPos[0]][Offset] not in CR_LB_SET:
|
|
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 CR_LB_SET:
|
|
self.Profile.FileLinesList[Line][Offset] = Value
|
|
Offset += 1
|
|
Line += 1
|
|
|
|
Offset = 0
|
|
while Offset <= EndPos[1]:
|
|
self.Profile.FileLinesList[EndPos[0]][Offset] = Value
|
|
Offset += 1
|
|
|
|
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
|
|
else:
|
|
MacroDict = self._MacroDict[self._CurSection[0], self._CurSection[1], self._CurSection[2]]
|
|
MacroDict[Macro] = Value
|
|
|
|
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 MacroDict and Macro in MacroDict:
|
|
return MacroDict[Macro]
|
|
|
|
# Lowest priority
|
|
if Macro in GlobalData.gPlatformDefines:
|
|
return GlobalData.gPlatformDefines[Macro]
|
|
return None
|
|
|
|
def _SectionHeaderParser(self, Section):
|
|
# [Defines]
|
|
# [FD.UiName]: use dummy instead if UI name is optional
|
|
# [FV.UiName]
|
|
# [Capsule.UiName]
|
|
# [Rule]: don't take rule section into account, macro is not allowed in this section
|
|
# [OptionRom.DriverName]
|
|
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]
|
|
elif len(ItemList) > 1:
|
|
self._CurSection = [ItemList[0], ItemList[1], TAB_COMMON]
|
|
elif len(ItemList) > 0:
|
|
self._CurSection = [ItemList[0], 'DUMMY', TAB_COMMON]
|
|
|
|
## PreprocessFile() method
|
|
#
|
|
# Preprocess file contents, replace comments with spaces.
|
|
# In the end, rewind the file buffer pointer to the beginning
|
|
# BUGBUG: No !include statement processing contained in this procedure
|
|
# !include statement should be expanded at the same FileLinesList[CurrentLineNumber - 1]
|
|
#
|
|
# @param self The object pointer
|
|
#
|
|
def PreprocessFile(self):
|
|
self.Rewind()
|
|
InComment = False
|
|
DoubleSlashComment = False
|
|
HashComment = False
|
|
# HashComment in quoted string " " is ignored.
|
|
InString = False
|
|
|
|
while not self._EndOfFile():
|
|
|
|
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() == TAB_LINE_BREAK:
|
|
self.CurrentLineNumber += 1
|
|
self.CurrentOffsetWithinLine = 0
|
|
if InComment and DoubleSlashComment:
|
|
InComment = False
|
|
DoubleSlashComment = False
|
|
if InComment and HashComment:
|
|
InComment = False
|
|
HashComment = False
|
|
# check for */ comment end
|
|
elif InComment and not DoubleSlashComment and not HashComment and self._CurrentChar() == TAB_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(TAB_SPACE_SPLIT)
|
|
self._GetOneChar()
|
|
# check for // comment
|
|
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() == TAB_COMMENT_SPLIT and not self._EndOfLine() and not InString:
|
|
InComment = True
|
|
HashComment = True
|
|
# check for /* comment start
|
|
elif self._CurrentChar() == TAB_BACK_SLASH and self._NextChar() == TAB_STAR:
|
|
self._SetCurrentCharValue(TAB_SPACE_SPLIT)
|
|
self._GetOneChar()
|
|
self._SetCurrentCharValue(TAB_SPACE_SPLIT)
|
|
self._GetOneChar()
|
|
InComment = True
|
|
else:
|
|
self._GetOneChar()
|
|
|
|
# restore from ListOfList to ListOfString
|
|
self.Profile.FileLinesList = ["".join(list) for list in self.Profile.FileLinesList]
|
|
self.Rewind()
|
|
|
|
## PreprocessIncludeFile() method
|
|
#
|
|
# Preprocess file contents, replace !include statements with file contents.
|
|
# In the end, rewind the file buffer pointer to the beginning
|
|
#
|
|
# @param self The object pointer
|
|
#
|
|
def PreprocessIncludeFile(self):
|
|
# nested include support
|
|
Processed = False
|
|
MacroDict = {}
|
|
while 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(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
Value = self._GetExpression()
|
|
MacroDict[Macro] = Value
|
|
|
|
elif self._Token == TAB_INCLUDE:
|
|
Processed = True
|
|
IncludeLine = self.CurrentLineNumber
|
|
IncludeOffset = self.CurrentOffsetWithinLine - len(TAB_INCLUDE)
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("include file name", self.FileName, self.CurrentLineNumber)
|
|
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)
|
|
if not MacroVal:
|
|
if Macro in MacroDict:
|
|
MacroVal = MacroDict[Macro]
|
|
if MacroVal is not None:
|
|
IncFileName = IncFileName.replace('$(' + Macro + ')', MacroVal, 1)
|
|
if MacroVal.find('$(') != -1:
|
|
PreIndex = StartPos
|
|
else:
|
|
PreIndex = StartPos + len(MacroVal)
|
|
else:
|
|
raise Warning("The Macro %s is not defined" %Macro, self.FileName, self.CurrentLineNumber)
|
|
StartPos = IncFileName.find('$(', PreIndex)
|
|
EndPos = IncFileName.find(')', StartPos+2)
|
|
|
|
IncludedFile = NormPath(IncFileName)
|
|
#
|
|
# First search the include file under the same directory as FDF file
|
|
#
|
|
IncludedFile1 = PathClass(IncludedFile, os.path.dirname(self.FileName))
|
|
ErrorCode = IncludedFile1.Validate()[0]
|
|
if ErrorCode != 0:
|
|
#
|
|
# Then search the include file under the same directory as DSC file
|
|
#
|
|
PlatformDir = ''
|
|
if GenFdsGlobalVariable.ActivePlatform:
|
|
PlatformDir = GenFdsGlobalVariable.ActivePlatform.Dir
|
|
elif GlobalData.gActivePlatform:
|
|
PlatformDir = GlobalData.gActivePlatform.MetaFile.Dir
|
|
IncludedFile1 = PathClass(IncludedFile, PlatformDir)
|
|
ErrorCode = IncludedFile1.Validate()[0]
|
|
if ErrorCode != 0:
|
|
#
|
|
# Also search file under the WORKSPACE directory
|
|
#
|
|
IncludedFile1 = PathClass(IncludedFile, GlobalData.gWorkspace)
|
|
ErrorCode = IncludedFile1.Validate()[0]
|
|
if ErrorCode != 0:
|
|
raise Warning("The include file does not exist under below directories: \n%s\n%s\n%s\n"%(os.path.dirname(self.FileName), PlatformDir, GlobalData.gWorkspace),
|
|
self.FileName, self.CurrentLineNumber)
|
|
|
|
if not IsValidInclude (IncludedFile1.Path, self.CurrentLineNumber):
|
|
raise Warning("The include file {0} is causing a include loop.\n".format (IncludedFile1.Path), self.FileName, self.CurrentLineNumber)
|
|
|
|
IncFileProfile = IncludeFileProfile(IncludedFile1.Path)
|
|
|
|
CurrentLine = self.CurrentLineNumber
|
|
CurrentOffset = self.CurrentOffsetWithinLine
|
|
# list index of the insertion, note that line number is 'CurrentLine + 1'
|
|
InsertAtLine = CurrentLine
|
|
ParentProfile = GetParentAtLine (CurrentLine)
|
|
if ParentProfile is not None:
|
|
ParentProfile.IncludeFileList.insert(0, IncFileProfile)
|
|
IncFileProfile.Level = ParentProfile.Level + 1
|
|
IncFileProfile.InsertStartLineNumber = InsertAtLine + 1
|
|
# deal with remaining portions after "!include filename", if exists.
|
|
if self._GetNextToken():
|
|
if self.CurrentLineNumber == CurrentLine:
|
|
RemainingLine = self._CurrentLine()[CurrentOffset:]
|
|
self.Profile.FileLinesList.insert(self.CurrentLineNumber, RemainingLine)
|
|
IncFileProfile.InsertAdjust += 1
|
|
self.CurrentLineNumber += 1
|
|
self.CurrentOffsetWithinLine = 0
|
|
|
|
for Line in IncFileProfile.FileLinesList:
|
|
self.Profile.FileLinesList.insert(InsertAtLine, Line)
|
|
self.CurrentLineNumber += 1
|
|
InsertAtLine += 1
|
|
|
|
# reversely sorted to better determine error in file
|
|
AllIncludeFileList.insert(0, IncFileProfile)
|
|
|
|
# comment out the processed include file statement
|
|
TempList = list(self.Profile.FileLinesList[IncludeLine - 1])
|
|
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)
|
|
Processed = False
|
|
# Preprocess done.
|
|
self.Rewind()
|
|
|
|
@staticmethod
|
|
def _GetIfListCurrentItemStat(IfList):
|
|
if len(IfList) == 0:
|
|
return True
|
|
|
|
for Item in IfList:
|
|
if Item[1] == False:
|
|
return False
|
|
|
|
return True
|
|
|
|
## PreprocessConditionalStatement() method
|
|
#
|
|
# Preprocess conditional statement.
|
|
# In the end, rewind the file buffer pointer to the beginning
|
|
#
|
|
# @param self The object pointer
|
|
#
|
|
def PreprocessConditionalStatement(self):
|
|
# IfList is a stack of if branches with elements of list [Pos, CondSatisfied, BranchDetermined]
|
|
IfList = []
|
|
RegionLayoutLine = 0
|
|
ReplacedLine = -1
|
|
while self._GetNextToken():
|
|
# Determine section name and the location dependent macro
|
|
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)
|
|
continue
|
|
# Replace macros except in RULE section or out of section
|
|
elif self._CurSection and ReplacedLine != self.CurrentLineNumber:
|
|
ReplacedLine = self.CurrentLineNumber
|
|
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 {TAB_IF_DEF, TAB_IF_N_DEF, TAB_IF, TAB_ELSE_IF}:
|
|
MacroName = CurLine[StartPos+2: EndPos]
|
|
MacroValue = self._GetMacroValue(MacroName)
|
|
if MacroValue is not None:
|
|
CurLine = CurLine.replace('$(' + MacroName + ')', MacroValue, 1)
|
|
if MacroValue.find('$(') != -1:
|
|
PreIndex = StartPos
|
|
else:
|
|
PreIndex = StartPos + len(MacroValue)
|
|
else:
|
|
PreIndex = EndPos + 1
|
|
StartPos = CurLine.find('$(', PreIndex)
|
|
EndPos = CurLine.find(')', StartPos+2)
|
|
self.Profile.FileLinesList[ReplacedLine - 1] = CurLine
|
|
continue
|
|
|
|
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(TAB_DEFINE)
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("Macro name", self.FileName, self.CurrentLineNumber)
|
|
Macro = self._Token
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(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):
|
|
continue
|
|
SetLine = self.CurrentLineNumber - 1
|
|
SetOffset = self.CurrentOffsetWithinLine - len('SET')
|
|
PcdPair = self._GetNextPcdSettings()
|
|
PcdName = "%s.%s" % (PcdPair[1], PcdPair[0])
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
Value = self._GetExpression()
|
|
Value = self._EvaluateConditional(Value, self.CurrentLineNumber, 'eval', True)
|
|
|
|
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 {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()
|
|
|
|
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 == 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 {TAB_ELSE_IF, TAB_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)))
|
|
else:
|
|
self._WipeOffArea.append((IfList[-1][0], ElseStartPos))
|
|
IfList[-1] = [ElseStartPos, True, IfList[-1][2]]
|
|
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]:
|
|
if IfList[-1][2]:
|
|
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':
|
|
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)))
|
|
else:
|
|
self._WipeOffArea.append((IfList[-1][0], (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1)))
|
|
|
|
IfList.pop()
|
|
elif not IfList: # Don't use PCDs inside conditional directive
|
|
if self.CurrentLineNumber <= RegionLayoutLine:
|
|
# Don't try the same line twice
|
|
continue
|
|
SetPcd = ShortcutPcdPattern.match(self.Profile.FileLinesList[self.CurrentLineNumber - 1])
|
|
if SetPcd:
|
|
self._PcdDict[SetPcd.group('name')] = SetPcd.group('value')
|
|
RegionLayoutLine = self.CurrentLineNumber
|
|
continue
|
|
RegionSize = RegionSizePattern.match(self.Profile.FileLinesList[self.CurrentLineNumber - 1])
|
|
if not RegionSize:
|
|
RegionLayoutLine = self.CurrentLineNumber
|
|
continue
|
|
RegionSizeGuid = RegionSizeGuidPattern.match(self.Profile.FileLinesList[self.CurrentLineNumber])
|
|
if not RegionSizeGuid:
|
|
RegionLayoutLine = self.CurrentLineNumber + 1
|
|
continue
|
|
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):
|
|
MacroDict = {}
|
|
|
|
# PCD macro
|
|
MacroDict.update(GlobalData.gPlatformPcds)
|
|
MacroDict.update(self._PcdDict)
|
|
|
|
# Lowest priority
|
|
MacroDict.update(GlobalData.gPlatformDefines)
|
|
|
|
if self._CurSection:
|
|
# Defines macro
|
|
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]
|
|
]
|
|
if ScopeMacro:
|
|
MacroDict.update(ScopeMacro)
|
|
|
|
MacroDict.update(GlobalData.gGlobalDefines)
|
|
MacroDict.update(GlobalData.gCommandLineDefines)
|
|
for Item in GlobalData.BuildOptionPcd:
|
|
if isinstance(Item, tuple):
|
|
continue
|
|
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()
|
|
if Op == 'eval':
|
|
try:
|
|
if Value:
|
|
return ValueExpression(Expression, MacroPcdDict)(True)
|
|
else:
|
|
return ValueExpression(Expression, MacroPcdDict)()
|
|
except WrnExpression as Excpt:
|
|
#
|
|
# Catch expression evaluation warning here. We need to report
|
|
# the precise number of line and return the evaluation result
|
|
#
|
|
EdkLogger.warn('Parser', "Suspicious expression: %s" % str(Excpt),
|
|
File=self.FileName, ExtraData=self._CurrentLine(),
|
|
Line=Line)
|
|
return Excpt.result
|
|
except Exception as Excpt:
|
|
if hasattr(Excpt, 'Pcd'):
|
|
if Excpt.Pcd in GlobalData.gPlatformOtherPcds:
|
|
Info = GlobalData.gPlatformOtherPcds[Excpt.Pcd]
|
|
raise Warning("Cannot use this PCD (%s) in an expression as"
|
|
" it must be defined in a [PcdsFixedAtBuild] or [PcdsFeatureFlag] section"
|
|
" of the DSC file (%s), and it is currently defined in this section:"
|
|
" %s, line #: %d." % (Excpt.Pcd, GlobalData.gPlatformOtherPcds['DSCFILE'], Info[0], Info[1]),
|
|
self.FileName, Line)
|
|
else:
|
|
raise Warning("PCD (%s) is not defined in DSC file (%s)" % (Excpt.Pcd, GlobalData.gPlatformOtherPcds['DSCFILE']),
|
|
self.FileName, Line)
|
|
else:
|
|
raise Warning(str(Excpt), self.FileName, Line)
|
|
else:
|
|
if Expression.startswith('$(') and Expression[-1] == ')':
|
|
Expression = Expression[2:-1]
|
|
return Expression in MacroPcdDict
|
|
|
|
## _IsToken() method
|
|
#
|
|
# Check whether input string is found from current char position along
|
|
# If found, the string value is put into self._Token
|
|
#
|
|
# @param self The object pointer
|
|
# @param String The string to search
|
|
# @param IgnoreCase Indicate case sensitive/non-sensitive search, default is case sensitive
|
|
# @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()
|
|
|
|
# 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())
|
|
else:
|
|
index = self._CurrentLine()[self.CurrentOffsetWithinLine: ].find(String)
|
|
if index == 0:
|
|
self.CurrentOffsetWithinLine += len(String)
|
|
self._Token = self._CurrentLine()[StartPos: self.CurrentOffsetWithinLine]
|
|
return True
|
|
return False
|
|
|
|
## _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
|
|
#
|
|
# @param self The object pointer
|
|
# @param Keyword The string to search
|
|
# @param IgnoreCase Indicate case sensitive/non-sensitive search, default is case sensitive
|
|
# @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()
|
|
|
|
# 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())
|
|
else:
|
|
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 SEPARATORS:
|
|
return False
|
|
self.CurrentOffsetWithinLine += len(KeyWord)
|
|
self._Token = self._CurrentLine()[StartPos: self.CurrentOffsetWithinLine]
|
|
return True
|
|
return False
|
|
|
|
def _GetExpression(self):
|
|
Line = self.Profile.FileLinesList[self.CurrentLineNumber - 1]
|
|
Index = len(Line) - 1
|
|
while Line[Index] in CR_LB_SET:
|
|
Index -= 1
|
|
ExpressionString = self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine:Index+1]
|
|
self.CurrentOffsetWithinLine += len(ExpressionString)
|
|
ExpressionString = ExpressionString.strip()
|
|
return ExpressionString
|
|
|
|
## _GetNextWord() method
|
|
#
|
|
# Get next C name from file lines
|
|
# 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():
|
|
return False
|
|
|
|
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()
|
|
if (TempChar >= 'a' and TempChar <= 'z') or (TempChar >= 'A' and TempChar <= 'Z') \
|
|
or (TempChar >= '0' and TempChar <= '9') or TempChar == '_' or TempChar == '-':
|
|
self._GetOneChar()
|
|
|
|
else:
|
|
break
|
|
|
|
self._Token = self._CurrentLine()[StartPos: self.CurrentOffsetWithinLine]
|
|
return True
|
|
|
|
return False
|
|
|
|
def _GetNextPcdWord(self):
|
|
self._SkipWhiteSpace()
|
|
if self._EndOfFile():
|
|
return False
|
|
|
|
TempChar = self._CurrentChar()
|
|
StartPos = self.CurrentOffsetWithinLine
|
|
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 == TAB_SECTION_START or TempChar == TAB_SECTION_END:
|
|
self._GetOneChar()
|
|
|
|
else:
|
|
break
|
|
|
|
self._Token = self._CurrentLine()[StartPos: self.CurrentOffsetWithinLine]
|
|
return True
|
|
|
|
return False
|
|
|
|
## _GetNextToken() method
|
|
#
|
|
# Get next token unit before a separator
|
|
# 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):
|
|
# Skip leading spaces, if exist.
|
|
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()
|
|
# Try to find the end char that is not a space and not in separator 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 SEPARATORS:
|
|
self._GetOneChar()
|
|
# if we happen to meet a separator as the first char, we must proceed to get it.
|
|
# That is, we get a token that is a separator char. normally it is the boundary of other tokens.
|
|
elif StartPos == self.CurrentOffsetWithinLine and TempChar in SEPARATORS:
|
|
self._GetOneChar()
|
|
break
|
|
else:
|
|
break
|
|
# else:
|
|
# return False
|
|
|
|
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()
|
|
if StartPos != self.CurrentOffsetWithinLine:
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
## _GetNextGuid() method
|
|
#
|
|
# Get next token unit before a separator
|
|
# 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():
|
|
return False
|
|
if GlobalData.gGuidPattern.match(self._Token) is not None:
|
|
return True
|
|
elif self._Token in GlobalData.gGuidDict:
|
|
return True
|
|
else:
|
|
self._UndoToken()
|
|
return False
|
|
|
|
@staticmethod
|
|
def _Verify(Name, Value, Scope):
|
|
# value verification only applies to numeric values.
|
|
if Scope not in TAB_PCD_NUMERIC_TYPES:
|
|
return
|
|
|
|
ValueNumber = 0
|
|
try:
|
|
ValueNumber = int(Value, 0)
|
|
except:
|
|
EdkLogger.error("FdfParser", FORMAT_INVALID, "The value is not valid dec or hex number for %s." % Name)
|
|
if ValueNumber < 0:
|
|
EdkLogger.error("FdfParser", FORMAT_INVALID, "The value can't be set to negative value for %s." % Name)
|
|
if ValueNumber > MAX_VAL_TYPE[Scope]:
|
|
EdkLogger.error("FdfParser", FORMAT_INVALID, "Too large value for %s." % Name)
|
|
return True
|
|
|
|
## _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()
|
|
return
|
|
|
|
|
|
StartPos = self.CurrentOffsetWithinLine
|
|
CurrentLine = self.CurrentLineNumber
|
|
while CurrentLine == self.CurrentLineNumber:
|
|
|
|
TempChar = self._CurrentChar()
|
|
# Try to find the end char that is not a space and not in separator 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 SEPARATORS:
|
|
if not self._UndoOneChar():
|
|
return
|
|
# if we happen to meet a separator as the first char, we must proceed to get it.
|
|
# That is, we get a token that is a separator char. normally it is the boundary of other tokens.
|
|
elif StartPos == self.CurrentOffsetWithinLine and TempChar in SEPARATORS:
|
|
return
|
|
else:
|
|
break
|
|
|
|
self._GetOneChar()
|
|
|
|
## _GetNextHexNumber() method
|
|
#
|
|
# Get next HEX data before a separator
|
|
# 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():
|
|
return False
|
|
if GlobalData.gHexPatternAll.match(self._Token):
|
|
return True
|
|
else:
|
|
self._UndoToken()
|
|
return False
|
|
|
|
## _GetNextDecimalNumber() method
|
|
#
|
|
# Get next decimal data before a separator
|
|
# 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():
|
|
return False
|
|
if self._Token.isdigit():
|
|
return True
|
|
else:
|
|
self._UndoToken()
|
|
return False
|
|
|
|
def _GetNextPcdSettings(self):
|
|
if not self._GetNextWord():
|
|
raise Warning.Expected("<PcdTokenSpaceCName>", self.FileName, self.CurrentLineNumber)
|
|
pcdTokenSpaceCName = self._Token
|
|
|
|
if not self._IsToken(TAB_SPLIT):
|
|
raise Warning.Expected(".", self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._GetNextWord():
|
|
raise Warning.Expected("<PcdCName>", self.FileName, self.CurrentLineNumber)
|
|
pcdCName = self._Token
|
|
|
|
Fields = []
|
|
while self._IsToken(TAB_SPLIT):
|
|
if not self._GetNextPcdWord():
|
|
raise Warning.Expected("Pcd Fields", self.FileName, self.CurrentLineNumber)
|
|
Fields.append(self._Token)
|
|
|
|
return (pcdCName, pcdTokenSpaceCName,TAB_SPLIT.join(Fields))
|
|
|
|
## _GetStringData() method
|
|
#
|
|
# Get string contents quoted in ""
|
|
# 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):
|
|
QuoteToUse = None
|
|
if self._Token.startswith(T_CHAR_DOUBLE_QUOTE) or self._Token.startswith("L\""):
|
|
QuoteToUse = T_CHAR_DOUBLE_QUOTE
|
|
elif self._Token.startswith(T_CHAR_SINGLE_QUOTE) or self._Token.startswith("L\'"):
|
|
QuoteToUse = T_CHAR_SINGLE_QUOTE
|
|
else:
|
|
return False
|
|
|
|
self._UndoToken()
|
|
self._SkipToToken(QuoteToUse)
|
|
currentLineNumber = self.CurrentLineNumber
|
|
|
|
if not self._SkipToToken(QuoteToUse):
|
|
raise Warning(QuoteToUse, self.FileName, self.CurrentLineNumber)
|
|
if currentLineNumber != self.CurrentLineNumber:
|
|
raise Warning(QuoteToUse, self.FileName, self.CurrentLineNumber)
|
|
self._Token = self._SkippedChars.rstrip(QuoteToUse)
|
|
return True
|
|
|
|
## _SkipToToken() method
|
|
#
|
|
# Search forward in file buffer for the string
|
|
# The skipped chars are put into self._SkippedChars
|
|
#
|
|
# @param self The object pointer
|
|
# @param String The string to search
|
|
# @param IgnoreCase Indicate case sensitive/non-sensitive search, default is case sensitive
|
|
# @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):
|
|
StartPos = self.GetFileBufferPos()
|
|
|
|
self._SkippedChars = ""
|
|
while not self._EndOfFile():
|
|
index = -1
|
|
if IgnoreCase:
|
|
index = self._CurrentLine()[self.CurrentOffsetWithinLine: ].upper().find(String.upper())
|
|
else:
|
|
index = self._CurrentLine()[self.CurrentOffsetWithinLine: ].find(String)
|
|
if index == 0:
|
|
self.CurrentOffsetWithinLine += len(String)
|
|
self._SkippedChars += String
|
|
return True
|
|
self._SkippedChars += str(self._CurrentChar())
|
|
self._GetOneChar()
|
|
|
|
self.SetFileBufferPos(StartPos)
|
|
self._SkippedChars = ""
|
|
return False
|
|
|
|
## GetFileBufferPos() method
|
|
#
|
|
# Return the tuple of current line and offset within the line
|
|
#
|
|
# @param self The object pointer
|
|
# @retval Tuple Line number and offset pair
|
|
#
|
|
def GetFileBufferPos(self):
|
|
return (self.CurrentLineNumber, self.CurrentOffsetWithinLine)
|
|
|
|
## SetFileBufferPos() method
|
|
#
|
|
# Restore the file buffer position
|
|
#
|
|
# @param self The object pointer
|
|
# @param Pos The new file buffer position
|
|
#
|
|
def SetFileBufferPos(self, Pos):
|
|
(self.CurrentLineNumber, self.CurrentOffsetWithinLine) = Pos
|
|
|
|
## Preprocess() method
|
|
#
|
|
# Preprocess comment, conditional directive, include directive, replace macro.
|
|
# Exception will be raised if syntax error found
|
|
#
|
|
# @param self The object pointer
|
|
#
|
|
def Preprocess(self):
|
|
self._StringToList()
|
|
self.PreprocessFile()
|
|
self.PreprocessIncludeFile()
|
|
self._StringToList()
|
|
self.PreprocessFile()
|
|
self.PreprocessConditionalStatement()
|
|
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():
|
|
pass
|
|
|
|
## ParseFile() method
|
|
#
|
|
# Parse the file profile buffer to extract fd, fv ... information
|
|
# Exception will be raised if syntax error found
|
|
#
|
|
# @param self The object pointer
|
|
#
|
|
def ParseFile(self):
|
|
try:
|
|
self.Preprocess()
|
|
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._GetRule() or self._GetOptionRom():
|
|
pass
|
|
|
|
except Warning as X:
|
|
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:
|
|
X.Message += ' near line %d, column %d: %s' \
|
|
% (X.LineNumber, 0, Profile.FileLinesList[X.LineNumber-1])
|
|
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(TAB_LINE_BREAK).rstrip(T_CHAR_CR))
|
|
raise
|
|
|
|
## SectionParser() method
|
|
#
|
|
# Parse the file section info
|
|
# Exception will be raised if syntax error found
|
|
#
|
|
# @param self The object pointer
|
|
# @param section The section string
|
|
|
|
def SectionParser(self, section):
|
|
S = section.upper()
|
|
if not S.startswith("[DEFINES") and not S.startswith("[FD.") and not S.startswith("[FV.") and not S.startswith("[CAPSULE.") \
|
|
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.], [Rule.], [OptionRom.], [FMPPAYLOAD.])", self.FileName, self.CurrentLineNumber)
|
|
|
|
## _GetDefines() method
|
|
#
|
|
# Get Defines section contents and store its data into AllMacrosList
|
|
#
|
|
# @param self The object pointer
|
|
# @retval True Successfully find a Defines
|
|
# @retval False Not able to find a Defines
|
|
#
|
|
def _GetDefines(self):
|
|
if not self._GetNextToken():
|
|
return False
|
|
|
|
S = self._Token.upper()
|
|
if S.startswith(TAB_SECTION_START) and not S.startswith("[DEFINES"):
|
|
self.SectionParser(S)
|
|
self._UndoToken()
|
|
return False
|
|
|
|
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)
|
|
raise Warning.Expected("[DEFINES", self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._IsToken(TAB_SECTION_END):
|
|
raise Warning.ExpectedBracketClose(self.FileName, self.CurrentLineNumber)
|
|
|
|
while self._GetNextWord():
|
|
# handle the SET statement
|
|
if self._Token == 'SET':
|
|
self._UndoToken()
|
|
self._GetSetStatement(None)
|
|
continue
|
|
|
|
Macro = self._Token
|
|
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
if not self._GetNextToken() or self._Token.startswith(TAB_SECTION_START):
|
|
raise Warning.Expected("MACRO value", self.FileName, self.CurrentLineNumber)
|
|
Value = self._Token
|
|
|
|
return False
|
|
|
|
##_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)
|
|
self.CurrentLineNumber = CurrentLine
|
|
self.CurrentOffsetWithinLine = CurrentOffset
|
|
|
|
## _GetFd() method
|
|
#
|
|
# Get FD section contents and store its data into FD dictionary of self.Profile
|
|
#
|
|
# @param self The object pointer
|
|
# @retval True Successfully find a FD
|
|
# @retval False Not able to find a FD
|
|
#
|
|
def _GetFd(self):
|
|
if not self._GetNextToken():
|
|
return False
|
|
|
|
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("[RULE.") and not S.startswith("[OPTIONROM."):
|
|
raise Warning("Unknown section", self.FileName, self.CurrentLineNumber)
|
|
self._UndoToken()
|
|
return False
|
|
|
|
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)
|
|
raise Warning.Expected("[FD.]", self.FileName, self.CurrentLineNumber)
|
|
|
|
FdName = self._GetUiName()
|
|
if FdName == "":
|
|
if len (self.Profile.FdDict) == 0:
|
|
FdName = GenFdsGlobalVariable.PlatformName
|
|
if FdName == "" and GlobalData.gActivePlatform:
|
|
FdName = GlobalData.gActivePlatform.PlatformName
|
|
self.Profile.FdNameNotSet = True
|
|
else:
|
|
raise Warning.Expected("FdName in [FD.] section", self.FileName, self.CurrentLineNumber)
|
|
self.CurrentFdName = FdName.upper()
|
|
|
|
if self.CurrentFdName in self.Profile.FdDict:
|
|
raise Warning("Unexpected the same FD name", self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._IsToken(TAB_SECTION_END):
|
|
raise Warning.ExpectedBracketClose(self.FileName, self.CurrentLineNumber)
|
|
|
|
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)
|
|
if not Status:
|
|
raise Warning("FD name error", self.FileName, self.CurrentLineNumber)
|
|
|
|
while self._GetTokenStatements(FdObj):
|
|
pass
|
|
for Attr in ("BaseAddress", "Size", "ErasePolarity"):
|
|
if getattr(FdObj, Attr) is None:
|
|
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._GetSetStatements(FdObj)
|
|
|
|
if not self._GetRegionLayout(FdObj):
|
|
raise Warning.Expected("region layout", self.FileName, self.CurrentLineNumber)
|
|
|
|
while self._GetRegionLayout(FdObj):
|
|
pass
|
|
return True
|
|
|
|
## _GetUiName() method
|
|
#
|
|
# Return the UI name of a section
|
|
#
|
|
# @param self The object pointer
|
|
# @retval FdName UI name
|
|
#
|
|
def _GetUiName(self):
|
|
Name = ""
|
|
if self._GetNextWord():
|
|
Name = self._Token
|
|
|
|
return Name
|
|
|
|
## _GetCreateFile() method
|
|
#
|
|
# Return the output file name of object
|
|
#
|
|
# @param self The object pointer
|
|
# @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(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("file name", self.FileName, self.CurrentLineNumber)
|
|
|
|
FileName = self._Token
|
|
Obj.CreateFileName = FileName
|
|
|
|
return True
|
|
|
|
def SetPcdLocalation(self,pcdpair):
|
|
self.Profile.PcdLocalDict[pcdpair] = (self.Profile.FileName,self.CurrentLineNumber)
|
|
|
|
## _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(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._GetNextHexNumber():
|
|
raise Warning.Expected("Hex base address", self.FileName, self.CurrentLineNumber)
|
|
|
|
Obj.BaseAddress = self._Token
|
|
|
|
if self._IsToken(TAB_VALUE_SPLIT):
|
|
pcdPair = self._GetNextPcdSettings()
|
|
Obj.BaseAddressPcd = pcdPair
|
|
self.Profile.PcdDict[pcdPair] = Obj.BaseAddress
|
|
self.SetPcdLocalation(pcdPair)
|
|
FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)
|
|
self.Profile.PcdFileLineDict[pcdPair] = FileLineTuple
|
|
return True
|
|
|
|
if self._IsKeyword("Size"):
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._GetNextHexNumber():
|
|
raise Warning.Expected("Hex size", self.FileName, self.CurrentLineNumber)
|
|
|
|
Size = self._Token
|
|
if self._IsToken(TAB_VALUE_SPLIT):
|
|
pcdPair = self._GetNextPcdSettings()
|
|
Obj.SizePcd = pcdPair
|
|
self.Profile.PcdDict[pcdPair] = Size
|
|
self.SetPcdLocalation(pcdPair)
|
|
FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)
|
|
self.Profile.PcdFileLineDict[pcdPair] = FileLineTuple
|
|
Obj.Size = int(Size, 0)
|
|
return True
|
|
|
|
if self._IsKeyword("ErasePolarity"):
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("Erase Polarity", self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._Token in {"1", "0"}:
|
|
raise Warning.Expected("1 or 0 Erase Polarity", self.FileName, self.CurrentLineNumber)
|
|
|
|
Obj.ErasePolarity = self._Token
|
|
return True
|
|
|
|
return self._GetBlockStatements(Obj)
|
|
|
|
## _GetAddressStatements() method
|
|
#
|
|
# Get address statements
|
|
#
|
|
# @param self The object pointer
|
|
# @param Obj for whom address statement is got
|
|
# @retval True Successfully find
|
|
# @retval False Not able to find
|
|
#
|
|
def _GetAddressStatements(self, Obj):
|
|
if self._IsKeyword("BsBaseAddress"):
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._GetNextDecimalNumber() and not self._GetNextHexNumber():
|
|
raise Warning.Expected("address", self.FileName, self.CurrentLineNumber)
|
|
|
|
BsAddress = int(self._Token, 0)
|
|
Obj.BsBaseAddress = BsAddress
|
|
|
|
if self._IsKeyword("RtBaseAddress"):
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._GetNextDecimalNumber() and not self._GetNextHexNumber():
|
|
raise Warning.Expected("address", self.FileName, self.CurrentLineNumber)
|
|
|
|
RtAddress = int(self._Token, 0)
|
|
Obj.RtBaseAddress = RtAddress
|
|
|
|
## _GetBlockStatements() method
|
|
#
|
|
# Get block statements
|
|
#
|
|
# @param self The object pointer
|
|
# @param Obj for whom block statement is got
|
|
#
|
|
def _GetBlockStatements(self, Obj):
|
|
IsBlock = False
|
|
while self._GetBlockStatement(Obj):
|
|
IsBlock = True
|
|
|
|
Item = Obj.BlockSizeList[-1]
|
|
if Item[0] is None or Item[1] is None:
|
|
raise Warning.Expected("block statement", self.FileName, self.CurrentLineNumber)
|
|
return IsBlock
|
|
|
|
## _GetBlockStatement() method
|
|
#
|
|
# Get block statement
|
|
#
|
|
# @param self The object pointer
|
|
# @param Obj for whom block statement is got
|
|
# @retval True Successfully find
|
|
# @retval False Not able to find
|
|
#
|
|
def _GetBlockStatement(self, Obj):
|
|
if not self._IsKeyword("BlockSize"):
|
|
return False
|
|
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._GetNextHexNumber() and not self._GetNextDecimalNumber():
|
|
raise Warning.Expected("Hex or Integer block size", self.FileName, self.CurrentLineNumber)
|
|
|
|
BlockSize = self._Token
|
|
BlockSizePcd = None
|
|
if self._IsToken(TAB_VALUE_SPLIT):
|
|
PcdPair = self._GetNextPcdSettings()
|
|
BlockSizePcd = PcdPair
|
|
self.Profile.PcdDict[PcdPair] = BlockSize
|
|
self.SetPcdLocalation(PcdPair)
|
|
FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)
|
|
self.Profile.PcdFileLineDict[PcdPair] = FileLineTuple
|
|
BlockSize = int(BlockSize, 0)
|
|
|
|
BlockNumber = None
|
|
if self._IsKeyword("NumBlocks"):
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._GetNextDecimalNumber() and not self._GetNextHexNumber():
|
|
raise Warning.Expected("block numbers", self.FileName, self.CurrentLineNumber)
|
|
|
|
BlockNumber = int(self._Token, 0)
|
|
|
|
Obj.BlockSizeList.append((BlockSize, BlockNumber, BlockSizePcd))
|
|
return True
|
|
|
|
## _GetDefineStatements() method
|
|
#
|
|
# Get define statements
|
|
#
|
|
# @param self The object pointer
|
|
# @param Obj for whom define statement is got
|
|
# @retval True Successfully find
|
|
# @retval False Not able to find
|
|
#
|
|
def _GetDefineStatements(self, Obj):
|
|
while self._GetDefineStatement(Obj):
|
|
pass
|
|
|
|
## _GetDefineStatement() method
|
|
#
|
|
# Get define statement
|
|
#
|
|
# @param self The object pointer
|
|
# @param Obj for whom define statement is got
|
|
# @retval True Successfully find
|
|
# @retval False Not able to find
|
|
#
|
|
def _GetDefineStatement(self, Obj):
|
|
if self._IsKeyword(TAB_DEFINE):
|
|
self._GetNextToken()
|
|
Macro = self._Token
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("value", self.FileName, self.CurrentLineNumber)
|
|
|
|
Value = self._Token
|
|
Macro = '$(' + Macro + ')'
|
|
Obj.DefineVarDict[Macro] = Value
|
|
return True
|
|
|
|
return False
|
|
|
|
## _GetSetStatements() method
|
|
#
|
|
# Get set statements
|
|
#
|
|
# @param self The object pointer
|
|
# @param Obj for whom set statement is got
|
|
# @retval True Successfully find
|
|
# @retval False Not able to find
|
|
#
|
|
def _GetSetStatements(self, Obj):
|
|
while self._GetSetStatement(Obj):
|
|
pass
|
|
|
|
## _GetSetStatement() method
|
|
#
|
|
# Get set statement
|
|
#
|
|
# @param self The object pointer
|
|
# @param Obj for whom set statement is got
|
|
# @retval True Successfully find
|
|
# @retval False Not able to find
|
|
#
|
|
def _GetSetStatement(self, Obj):
|
|
if self._IsKeyword("SET"):
|
|
PcdPair = self._GetNextPcdSettings()
|
|
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
Value = self._GetExpression()
|
|
Value = self._EvaluateConditional(Value, self.CurrentLineNumber, 'eval', True)
|
|
|
|
if Obj:
|
|
Obj.SetVarDict[PcdPair] = Value
|
|
self.Profile.PcdDict[PcdPair] = Value
|
|
self.SetPcdLocalation(PcdPair)
|
|
FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)
|
|
self.Profile.PcdFileLineDict[PcdPair] = FileLineTuple
|
|
return True
|
|
|
|
return False
|
|
|
|
## _CalcRegionExpr(self)
|
|
#
|
|
# Calculate expression for offset or size of a region
|
|
#
|
|
# @return: None if invalid expression
|
|
# Calculated number if successfully
|
|
#
|
|
def _CalcRegionExpr(self):
|
|
StartPos = self.GetFileBufferPos()
|
|
Expr = ''
|
|
PairCount = 0
|
|
while not self._EndOfFile():
|
|
CurCh = self._CurrentChar()
|
|
if CurCh == '(':
|
|
PairCount += 1
|
|
elif CurCh == ')':
|
|
PairCount -= 1
|
|
|
|
if CurCh in '|\r\n' and PairCount == 0:
|
|
break
|
|
Expr += CurCh
|
|
self._GetOneChar()
|
|
try:
|
|
return int(
|
|
ValueExpression(Expr,
|
|
self._CollectMacroPcd()
|
|
)(True), 0)
|
|
except Exception:
|
|
self.SetFileBufferPos(StartPos)
|
|
return None
|
|
|
|
## _GetRegionLayout() method
|
|
#
|
|
# Get region layout for FD
|
|
#
|
|
# @param self The object pointer
|
|
# @param theFd for whom region is got
|
|
# @retval True Successfully find
|
|
# @retval False Not able to find
|
|
#
|
|
def _GetRegionLayout(self, theFd):
|
|
Offset = self._CalcRegionExpr()
|
|
if Offset is None:
|
|
return False
|
|
|
|
RegionObj = Region()
|
|
RegionObj.Offset = Offset
|
|
theFd.RegionList.append(RegionObj)
|
|
|
|
if not self._IsToken(TAB_VALUE_SPLIT):
|
|
raise Warning.Expected("'|'", self.FileName, self.CurrentLineNumber)
|
|
|
|
Size = self._CalcRegionExpr()
|
|
if Size is None:
|
|
raise Warning.Expected("Region Size", self.FileName, self.CurrentLineNumber)
|
|
RegionObj.Size = Size
|
|
|
|
if not self._GetNextWord():
|
|
return True
|
|
|
|
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:]))
|
|
if IsRegionPcd:
|
|
RegionObj.PcdOffset = self._GetNextPcdSettings()
|
|
self.Profile.PcdDict[RegionObj.PcdOffset] = "0x%08X" % (RegionObj.Offset + int(theFd.BaseAddress, 0))
|
|
self.SetPcdLocalation(RegionObj.PcdOffset)
|
|
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(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
|
|
FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)
|
|
self.Profile.PcdFileLineDict[RegionObj.PcdSize] = FileLineTuple
|
|
|
|
if not self._GetNextWord():
|
|
return True
|
|
|
|
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 == "CAPSULE":
|
|
self._UndoToken()
|
|
self._GetRegionCapType(RegionObj)
|
|
|
|
elif self._Token == "FILE":
|
|
self._UndoToken()
|
|
self._GetRegionFileType(RegionObj)
|
|
|
|
elif self._Token == "INF":
|
|
self._UndoToken()
|
|
RegionObj.RegionType = "INF"
|
|
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)
|
|
else:
|
|
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",
|
|
self.FileName, self.CurrentLineNumber)
|
|
|
|
return True
|
|
|
|
## _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):
|
|
raise Warning.Expected("'FV'", self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
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())
|
|
|
|
while self._IsKeyword(BINARY_FILE_TYPE_FV):
|
|
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("FV name", self.FileName, self.CurrentLineNumber)
|
|
|
|
RegionObj.RegionDataList.append((self._Token).upper())
|
|
|
|
## _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"):
|
|
raise Warning.Expected("'CAPSULE'", self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("CAPSULE name", self.FileName, self.CurrentLineNumber)
|
|
|
|
RegionObj.RegionType = "CAPSULE"
|
|
RegionObj.RegionDataList.append(self._Token)
|
|
|
|
while self._IsKeyword("CAPSULE"):
|
|
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("CAPSULE name", self.FileName, self.CurrentLineNumber)
|
|
|
|
RegionObj.RegionDataList.append(self._Token)
|
|
|
|
## _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"):
|
|
raise Warning.Expected("'FILE'", self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("File name", self.FileName, self.CurrentLineNumber)
|
|
|
|
RegionObj.RegionType = "FILE"
|
|
RegionObj.RegionDataList.append(self._Token)
|
|
|
|
while self._IsKeyword("FILE"):
|
|
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("FILE name", self.FileName, self.CurrentLineNumber)
|
|
|
|
RegionObj.RegionDataList.append(self._Token)
|
|
|
|
## _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"):
|
|
raise Warning.Expected("Region Data type", self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._IsToken("{"):
|
|
raise Warning.ExpectedCurlyOpen(self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._GetNextHexNumber():
|
|
raise Warning.Expected("Hex byte", self.FileName, self.CurrentLineNumber)
|
|
|
|
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
|
|
AllStrLen = len (AllString)
|
|
DataString = ""
|
|
while AllStrLen > 4:
|
|
DataString = DataString + "0x" + AllString[AllStrLen - 2: AllStrLen] + TAB_COMMA_SPLIT
|
|
AllStrLen = AllStrLen - 2
|
|
DataString = DataString + AllString[:AllStrLen] + TAB_COMMA_SPLIT
|
|
|
|
# byte value array
|
|
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:
|
|
raise Warning("Hex byte(must be 2 digits) too long", self.FileName, self.CurrentLineNumber)
|
|
DataString += self._Token
|
|
DataString += TAB_COMMA_SPLIT
|
|
|
|
if not self._IsToken(T_CHAR_BRACE_R):
|
|
raise Warning.ExpectedCurlyClose(self.FileName, self.CurrentLineNumber)
|
|
|
|
DataString = DataString.rstrip(TAB_COMMA_SPLIT)
|
|
RegionObj.RegionType = "DATA"
|
|
RegionObj.RegionDataList.append(DataString)
|
|
|
|
while self._IsKeyword("DATA"):
|
|
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._IsToken("{"):
|
|
raise Warning.ExpectedCurlyOpen(self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._GetNextHexNumber():
|
|
raise Warning.Expected("Hex byte", self.FileName, self.CurrentLineNumber)
|
|
|
|
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
|
|
AllStrLen = len (AllString)
|
|
DataString = ""
|
|
while AllStrLen > 4:
|
|
DataString = DataString + "0x" + AllString[AllStrLen - 2: AllStrLen] + TAB_COMMA_SPLIT
|
|
AllStrLen = AllStrLen - 2
|
|
DataString = DataString + AllString[:AllStrLen] + TAB_COMMA_SPLIT
|
|
|
|
# byte value array
|
|
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:
|
|
raise Warning("Hex byte(must be 2 digits) too long", self.FileName, self.CurrentLineNumber)
|
|
DataString += self._Token
|
|
DataString += TAB_COMMA_SPLIT
|
|
|
|
if not self._IsToken(T_CHAR_BRACE_R):
|
|
raise Warning.ExpectedCurlyClose(self.FileName, self.CurrentLineNumber)
|
|
|
|
DataString = DataString.rstrip(TAB_COMMA_SPLIT)
|
|
RegionObj.RegionDataList.append(DataString)
|
|
|
|
## _GetFv() method
|
|
#
|
|
# Get FV section contents and store its data into FV dictionary of self.Profile
|
|
#
|
|
# @param self The object pointer
|
|
# @retval True Successfully find a FV
|
|
# @retval False Not able to find a FV
|
|
#
|
|
def _GetFv(self):
|
|
if not self._GetNextToken():
|
|
return False
|
|
|
|
S = self._Token.upper()
|
|
if S.startswith(TAB_SECTION_START) and not S.startswith("[FV."):
|
|
self.SectionParser(S)
|
|
self._UndoToken()
|
|
return False
|
|
|
|
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)
|
|
|
|
FvName = self._GetUiName()
|
|
self.CurrentFvName = FvName.upper()
|
|
|
|
if not self._IsToken(TAB_SECTION_END):
|
|
raise Warning.ExpectedBracketClose(self.FileName, self.CurrentLineNumber)
|
|
|
|
FvObj = FV(Name=self.CurrentFvName)
|
|
self.Profile.FvDict[self.CurrentFvName] = FvObj
|
|
|
|
Status = self._GetCreateFile(FvObj)
|
|
if not Status:
|
|
raise Warning("FV name error", self.FileName, self.CurrentLineNumber)
|
|
|
|
self._GetDefineStatements(FvObj)
|
|
|
|
self._GetAddressStatements(FvObj)
|
|
|
|
while True:
|
|
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)):
|
|
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)
|
|
self._GetAprioriSection(FvObj)
|
|
|
|
while True:
|
|
isInf = self._GetInfStatement(FvObj)
|
|
isFile = self._GetFileStatement(FvObj)
|
|
if not isInf and not isFile:
|
|
break
|
|
|
|
return True
|
|
|
|
## _GetFvAlignment() method
|
|
#
|
|
# Get alignment for FV
|
|
#
|
|
# @param self The object pointer
|
|
# @param Obj for whom alignment is got
|
|
# @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"):
|
|
return False
|
|
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
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", \
|
|
"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
|
|
return True
|
|
|
|
## _GetFvBaseAddress() method
|
|
#
|
|
# Get BaseAddress for FV
|
|
#
|
|
# @param self The object pointer
|
|
# @param Obj for whom FvBaseAddress is got
|
|
# @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"):
|
|
return False
|
|
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
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
|
|
return True
|
|
|
|
## _GetFvForceRebase() method
|
|
#
|
|
# Get FvForceRebase for FV
|
|
#
|
|
# @param self The object pointer
|
|
# @param Obj for whom FvForceRebase is got
|
|
# @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"):
|
|
return False
|
|
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
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() in {"TRUE", "1", "0X1", "0X01"}:
|
|
Obj.FvForceRebase = True
|
|
elif self._Token.upper() in {"FALSE", "0", "0X0", "0X00"}:
|
|
Obj.FvForceRebase = False
|
|
else:
|
|
Obj.FvForceRebase = None
|
|
|
|
return True
|
|
|
|
|
|
## _GetFvAttributes() method
|
|
#
|
|
# Get attributes for FV
|
|
#
|
|
# @param self The object pointer
|
|
# @param Obj for whom attribute is got
|
|
# @retval None
|
|
#
|
|
def _GetFvAttributes(self, FvObj):
|
|
IsWordToken = False
|
|
while self._GetNextWord():
|
|
IsWordToken = True
|
|
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()
|
|
return False
|
|
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
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
|
|
|
|
return IsWordToken
|
|
|
|
## _GetFvNameGuid() method
|
|
#
|
|
# Get FV GUID for FV
|
|
#
|
|
# @param self The object pointer
|
|
# @param Obj for whom GUID is got
|
|
# @retval None
|
|
#
|
|
def _GetFvNameGuid(self, FvObj):
|
|
if not self._IsKeyword("FvNameGuid"):
|
|
return False
|
|
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._GetNextGuid():
|
|
raise Warning.Expected("GUID value", self.FileName, self.CurrentLineNumber)
|
|
if self._Token in GlobalData.gGuidDict:
|
|
self._Token = GuidStructureStringToGuidString(GlobalData.gGuidDict[self._Token]).upper()
|
|
|
|
FvObj.FvNameGuid = self._Token
|
|
|
|
return True
|
|
|
|
def _GetFvNameString(self, FvObj):
|
|
if not self._IsKeyword("FvNameString"):
|
|
return False
|
|
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._GetNextToken() or self._Token.upper() not in {'TRUE', 'FALSE'}:
|
|
raise Warning.Expected("TRUE or FALSE for FvNameString", self.FileName, self.CurrentLineNumber)
|
|
|
|
FvObj.FvNameString = self._Token
|
|
|
|
return True
|
|
|
|
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"):
|
|
raise Warning.Expected("'TYPE'", self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
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)
|
|
|
|
if not self._IsToken("{"):
|
|
raise Warning.ExpectedCurlyOpen(self.FileName, self.CurrentLineNumber)
|
|
|
|
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)
|
|
|
|
if self._Token == 'DATA':
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._IsToken("{"):
|
|
raise Warning.ExpectedCurlyOpen(self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._GetNextHexNumber():
|
|
raise Warning.Expected("Hex byte", self.FileName, self.CurrentLineNumber)
|
|
|
|
if len(self._Token) > 4:
|
|
raise Warning("Hex byte(must be 2 digits) too long", self.FileName, self.CurrentLineNumber)
|
|
|
|
DataString = self._Token
|
|
DataString += TAB_COMMA_SPLIT
|
|
|
|
while self._IsToken(TAB_COMMA_SPLIT):
|
|
if not self._GetNextHexNumber():
|
|
raise Warning("Invalid Hex number", self.FileName, self.CurrentLineNumber)
|
|
if len(self._Token) > 4:
|
|
raise Warning("Hex byte(must be 2 digits) too long", self.FileName, self.CurrentLineNumber)
|
|
DataString += self._Token
|
|
DataString += TAB_COMMA_SPLIT
|
|
|
|
if not self._IsToken(T_CHAR_BRACE_R):
|
|
raise Warning.ExpectedCurlyClose(self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._IsToken(T_CHAR_BRACE_R):
|
|
raise Warning.ExpectedCurlyClose(self.FileName, self.CurrentLineNumber)
|
|
|
|
DataString = DataString.rstrip(TAB_COMMA_SPLIT)
|
|
FvObj.FvExtEntryData.append(DataString)
|
|
|
|
if self._Token == 'FILE':
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("FV Extension Entry file path At Line ", self.FileName, self.CurrentLineNumber)
|
|
|
|
FvObj.FvExtEntryData.append(self._Token)
|
|
|
|
if not self._IsToken(T_CHAR_BRACE_R):
|
|
raise Warning.ExpectedCurlyClose(self.FileName, self.CurrentLineNumber)
|
|
|
|
return True
|
|
|
|
## _GetAprioriSection() method
|
|
#
|
|
# Get token statements
|
|
#
|
|
# @param self The object pointer
|
|
# @param FvObj for whom apriori is got
|
|
# @retval True Successfully find apriori statement
|
|
# @retval False Not able to find apriori statement
|
|
#
|
|
def _GetAprioriSection(self, FvObj):
|
|
if not self._IsKeyword("APRIORI"):
|
|
return False
|
|
|
|
if not self._IsKeyword("PEI") and not self._IsKeyword("DXE"):
|
|
raise Warning.Expected("Apriori file type", self.FileName, self.CurrentLineNumber)
|
|
AprType = self._Token
|
|
|
|
if not self._IsToken("{"):
|
|
raise Warning.ExpectedCurlyOpen(self.FileName, self.CurrentLineNumber)
|
|
|
|
AprSectionObj = AprioriSection()
|
|
AprSectionObj.AprioriType = AprType
|
|
|
|
self._GetDefineStatements(AprSectionObj)
|
|
|
|
while True:
|
|
IsInf = self._GetInfStatement(AprSectionObj)
|
|
IsFile = self._GetFileStatement(AprSectionObj)
|
|
if not IsInf and not IsFile:
|
|
break
|
|
|
|
if not self._IsToken(T_CHAR_BRACE_R):
|
|
raise Warning.ExpectedCurlyClose(self.FileName, self.CurrentLineNumber)
|
|
|
|
FvObj.AprioriSectionList.append(AprSectionObj)
|
|
return True
|
|
|
|
def _ParseInfStatement(self):
|
|
if not self._IsKeyword("INF"):
|
|
return None
|
|
|
|
ffsInf = FfsInfStatement()
|
|
self._GetInfOptions(ffsInf)
|
|
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("INF file path", self.FileName, self.CurrentLineNumber)
|
|
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()
|
|
|
|
#Replace $(SAPCE) with real space
|
|
ffsInf.InfFileName = ffsInf.InfFileName.replace('$(SPACE)', ' ')
|
|
|
|
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:
|
|
EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo)
|
|
|
|
NewFileName = ffsInf.InfFileName
|
|
if ffsInf.OverrideGuid:
|
|
NewFileName = ProcessDuplicatedInf(PathClass(ffsInf.InfFileName,GenFdsGlobalVariable.WorkSpaceDir), ffsInf.OverrideGuid, GenFdsGlobalVariable.WorkSpaceDir).Path
|
|
|
|
if not NewFileName in self.Profile.InfList:
|
|
self.Profile.InfList.append(NewFileName)
|
|
FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)
|
|
self.Profile.InfFileLineList.append(FileLineTuple)
|
|
if ffsInf.UseArch:
|
|
if ffsInf.UseArch not in self.Profile.InfDict:
|
|
self.Profile.InfDict[ffsInf.UseArch] = [ffsInf.InfFileName]
|
|
else:
|
|
self.Profile.InfDict[ffsInf.UseArch].append(ffsInf.InfFileName)
|
|
else:
|
|
self.Profile.InfDict['ArchTBD'].append(ffsInf.InfFileName)
|
|
|
|
if self._IsToken(TAB_VALUE_SPLIT):
|
|
if self._IsKeyword('RELOCS_STRIPPED'):
|
|
ffsInf.KeepReloc = False
|
|
elif self._IsKeyword('RELOCS_RETAINED'):
|
|
ffsInf.KeepReloc = True
|
|
else:
|
|
raise Warning("Unknown reloc strip flag '%s'" % self._Token, self.FileName, self.CurrentLineNumber)
|
|
return ffsInf
|
|
|
|
## _GetInfStatement() method
|
|
#
|
|
# Get INF statements
|
|
#
|
|
# @param self The object pointer
|
|
# @param Obj for whom inf statement is got
|
|
# @retval True Successfully find inf statement
|
|
# @retval False Not able to find inf statement
|
|
#
|
|
def _GetInfStatement(self, Obj, ForCapsule=False):
|
|
ffsInf = self._ParseInfStatement()
|
|
if not ffsInf:
|
|
return False
|
|
|
|
if ForCapsule:
|
|
myCapsuleFfs = CapsuleFfs()
|
|
myCapsuleFfs.Ffs = ffsInf
|
|
Obj.CapsuleDataList.append(myCapsuleFfs)
|
|
else:
|
|
Obj.FfsList.append(ffsInf)
|
|
return True
|
|
|
|
## _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(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
if not self._GetNextGuid():
|
|
raise Warning.Expected("GUID value", self.FileName, self.CurrentLineNumber)
|
|
if self._Token in GlobalData.gGuidDict:
|
|
self._Token = GuidStructureStringToGuidString(GlobalData.gGuidDict[self._Token]).upper()
|
|
FfsInfObj.OverrideGuid = self._Token
|
|
|
|
if self._IsKeyword("RuleOverride"):
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("Rule name", self.FileName, self.CurrentLineNumber)
|
|
FfsInfObj.Rule = self._Token
|
|
|
|
if self._IsKeyword("VERSION"):
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("Version", self.FileName, self.CurrentLineNumber)
|
|
|
|
if self._GetStringData():
|
|
FfsInfObj.Version = self._Token
|
|
|
|
if self._IsKeyword(BINARY_FILE_TYPE_UI):
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("UI name", self.FileName, self.CurrentLineNumber)
|
|
|
|
if self._GetStringData():
|
|
FfsInfObj.Ui = self._Token
|
|
|
|
if self._IsKeyword("USE"):
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("ARCH name", self.FileName, self.CurrentLineNumber)
|
|
FfsInfObj.UseArch = self._Token
|
|
|
|
|
|
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()
|
|
return
|
|
|
|
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)
|
|
|
|
if not self._IsToken(TAB_COMMA_SPLIT):
|
|
break
|
|
|
|
## _GetFileStatement() method
|
|
#
|
|
# Get FILE statements
|
|
#
|
|
# @param self The object pointer
|
|
# @param Obj for whom FILE statement is got
|
|
# @retval True Successfully find FILE statement
|
|
# @retval False Not able to find FILE statement
|
|
#
|
|
def _GetFileStatement(self, Obj, ForCapsule = False):
|
|
if not self._IsKeyword("FILE"):
|
|
return False
|
|
|
|
if not self._GetNextWord():
|
|
raise Warning.Expected("FFS type", self.FileName, self.CurrentLineNumber)
|
|
|
|
if ForCapsule and self._Token == 'DATA':
|
|
self._UndoToken()
|
|
self._UndoToken()
|
|
return False
|
|
|
|
FfsFileObj = FileStatement()
|
|
FfsFileObj.FvFileType = self._Token
|
|
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
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("("):
|
|
raise Warning.Expected("'('", self.FileName, self.CurrentLineNumber)
|
|
PcdPair = self._GetNextPcdSettings()
|
|
if not self._IsToken(")"):
|
|
raise Warning.Expected("')'", self.FileName, self.CurrentLineNumber)
|
|
self._Token = 'PCD('+PcdPair[1]+TAB_SPLIT+PcdPair[0]+')'
|
|
|
|
if self._Token in GlobalData.gGuidDict:
|
|
self._Token = GuidStructureStringToGuidString(GlobalData.gGuidDict[self._Token]).upper()
|
|
FfsFileObj.NameGuid = self._Token
|
|
|
|
self._GetFilePart(FfsFileObj)
|
|
|
|
if ForCapsule:
|
|
capsuleFfs = CapsuleFfs()
|
|
capsuleFfs.Ffs = FfsFileObj
|
|
Obj.CapsuleDataList.append(capsuleFfs)
|
|
else:
|
|
Obj.FfsList.append(FfsFileObj)
|
|
|
|
return True
|
|
|
|
## _FileCouldHaveRelocFlag() method
|
|
#
|
|
# Check whether reloc strip flag can be set for a file type.
|
|
#
|
|
# @param FileType The file type to check with
|
|
# @retval True This type could have relocation strip flag
|
|
# @retval False No way to have it
|
|
#
|
|
@staticmethod
|
|
def _FileCouldHaveRelocFlag (FileType):
|
|
if FileType in {SUP_MODULE_SEC, SUP_MODULE_PEI_CORE, SUP_MODULE_PEIM, SUP_MODULE_MM_CORE_STANDALONE, 'PEI_DXE_COMBO'}:
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
## _SectionCouldHaveRelocFlag() method
|
|
#
|
|
# Check whether reloc strip flag can be set for a section type.
|
|
#
|
|
# @param SectionType The section type to check with
|
|
# @retval True This type could have relocation strip flag
|
|
# @retval False No way to have it
|
|
#
|
|
@staticmethod
|
|
def _SectionCouldHaveRelocFlag (SectionType):
|
|
if SectionType in {BINARY_FILE_TYPE_TE, BINARY_FILE_TYPE_PE32}:
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
## _GetFilePart() method
|
|
#
|
|
# Get components for FILE statement
|
|
#
|
|
# @param self The object pointer
|
|
# @param FfsFileObj for whom component is got
|
|
#
|
|
def _GetFilePart(self, 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':
|
|
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("{"):
|
|
raise Warning.ExpectedCurlyOpen(self.FileName, self.CurrentLineNumber)
|
|
|
|
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(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("FV name", self.FileName, self.CurrentLineNumber)
|
|
FfsFileObj.FvName = self._Token
|
|
|
|
elif self._Token == "FD":
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("FD name", self.FileName, self.CurrentLineNumber)
|
|
FfsFileObj.FdName = self._Token
|
|
|
|
elif self._Token in {TAB_DEFINE, "APRIORI", "SECTION"}:
|
|
self._UndoToken()
|
|
self._GetSectionData(FfsFileObj)
|
|
|
|
elif hasattr(FfsFileObj, 'FvFileType') and FfsFileObj.FvFileType == 'RAW':
|
|
self._UndoToken()
|
|
self._GetRAWData(FfsFileObj)
|
|
|
|
else:
|
|
FfsFileObj.CurrentLineNum = self.CurrentLineNumber
|
|
FfsFileObj.CurrentLineContent = self._CurrentLine()
|
|
FfsFileObj.FileName = self._Token.replace('$(SPACE)', ' ')
|
|
self._VerifyFile(FfsFileObj.FileName)
|
|
|
|
if not self._IsToken(T_CHAR_BRACE_R):
|
|
raise Warning.ExpectedCurlyClose(self.FileName, self.CurrentLineNumber)
|
|
|
|
## _GetRAWData() method
|
|
#
|
|
# Get RAW data for FILE statement
|
|
#
|
|
# @param self The object pointer
|
|
# @param FfsFileObj for whom section is got
|
|
#
|
|
def _GetRAWData(self, FfsFileObj):
|
|
FfsFileObj.FileName = []
|
|
FfsFileObj.SubAlignment = []
|
|
while True:
|
|
AlignValue = None
|
|
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():
|
|
raise Warning.Expected("Filename value", self.FileName, self.CurrentLineNumber)
|
|
|
|
FileName = self._Token.replace('$(SPACE)', ' ')
|
|
if FileName == T_CHAR_BRACE_R:
|
|
self._UndoToken()
|
|
raise Warning.Expected("Filename value", self.FileName, self.CurrentLineNumber)
|
|
|
|
self._VerifyFile(FileName)
|
|
File = PathClass(NormPath(FileName), GenFdsGlobalVariable.WorkSpaceDir)
|
|
FfsFileObj.FileName.append(File.Path)
|
|
FfsFileObj.SubAlignment.append(AlignValue)
|
|
|
|
if self._IsToken(T_CHAR_BRACE_R):
|
|
self._UndoToken()
|
|
break
|
|
|
|
if len(FfsFileObj.SubAlignment) == 1:
|
|
FfsFileObj.SubAlignment = FfsFileObj.SubAlignment[0]
|
|
if len(FfsFileObj.FileName) == 1:
|
|
FfsFileObj.FileName = FfsFileObj.FileName[0]
|
|
|
|
## _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(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)
|
|
|
|
if not self._IsToken(TAB_COMMA_SPLIT):
|
|
break
|
|
|
|
else:
|
|
self._UndoToken()
|
|
|
|
if self._IsKeyword("FIXED", True):
|
|
FfsFileObj.Fixed = True
|
|
|
|
if self._IsKeyword("CHECKSUM", True):
|
|
FfsFileObj.CheckSum = True
|
|
|
|
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
|
|
|
|
## _GetAlignment() method
|
|
#
|
|
# Return the alignment value
|
|
#
|
|
# @param self The object pointer
|
|
# @retval True Successfully find alignment
|
|
# @retval False Not able to find alignment
|
|
#
|
|
def _GetAlignment(self):
|
|
if self._IsKeyword("Align", True):
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("alignment value", self.FileName, self.CurrentLineNumber)
|
|
return True
|
|
|
|
return False
|
|
|
|
## _GetSectionData() method
|
|
#
|
|
# Get section data for FILE statement
|
|
#
|
|
# @param self The object pointer
|
|
# @param FfsFileObj for whom section is got
|
|
#
|
|
def _GetSectionData(self, FfsFileObj):
|
|
self._GetDefineStatements(FfsFileObj)
|
|
|
|
while True:
|
|
IsLeafSection = self._GetLeafSection(FfsFileObj)
|
|
IsEncapSection = self._GetEncapsulationSec(FfsFileObj)
|
|
if not IsLeafSection and not IsEncapSection:
|
|
break
|
|
|
|
## _GetLeafSection() method
|
|
#
|
|
# Get leaf section for Obj
|
|
#
|
|
# @param self The object pointer
|
|
# @param Obj for whom leaf section is got
|
|
# @retval True Successfully find section statement
|
|
# @retval False Not able to find section statement
|
|
#
|
|
def _GetLeafSection(self, Obj):
|
|
OldPos = self.GetFileBufferPos()
|
|
|
|
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 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(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("Build number value", self.FileName, self.CurrentLineNumber)
|
|
|
|
BuildNum = self._Token
|
|
|
|
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(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("version", self.FileName, self.CurrentLineNumber)
|
|
VerSectionObj = VerSection()
|
|
VerSectionObj.Alignment = AlignValue
|
|
VerSectionObj.BuildNum = BuildNum
|
|
if self._GetStringData():
|
|
VerSectionObj.StringData = self._Token
|
|
else:
|
|
VerSectionObj.FileName = self._Token
|
|
Obj.SectionList.append(VerSectionObj)
|
|
|
|
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(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("UI", self.FileName, self.CurrentLineNumber)
|
|
UiSectionObj = UiSection()
|
|
UiSectionObj.Alignment = AlignValue
|
|
if self._GetStringData():
|
|
UiSectionObj.StringData = self._Token
|
|
else:
|
|
UiSectionObj.FileName = self._Token
|
|
Obj.SectionList.append(UiSectionObj)
|
|
|
|
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(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("FV name or FV file path", self.FileName, self.CurrentLineNumber)
|
|
|
|
FvName = self._Token
|
|
FvObj = None
|
|
|
|
if self._IsToken("{"):
|
|
FvObj = FV()
|
|
FvObj.UiFvName = FvName.upper()
|
|
self._GetDefineStatements(FvObj)
|
|
|
|
self._GetBlockStatement(FvObj)
|
|
self._GetSetStatements(FvObj)
|
|
self._GetFvAlignment(FvObj)
|
|
self._GetFvAttributes(FvObj)
|
|
|
|
while True:
|
|
IsInf = self._GetInfStatement(FvObj)
|
|
IsFile = self._GetFileStatement(FvObj)
|
|
if not IsInf and not IsFile:
|
|
break
|
|
|
|
if not self._IsToken(T_CHAR_BRACE_R):
|
|
raise Warning.ExpectedCurlyClose(self.FileName, self.CurrentLineNumber)
|
|
|
|
FvImageSectionObj = FvImageSection()
|
|
FvImageSectionObj.Alignment = AlignValue
|
|
if FvObj is not None:
|
|
FvImageSectionObj.Fv = FvObj
|
|
FvImageSectionObj.FvName = None
|
|
else:
|
|
FvImageSectionObj.FvName = FvName.upper()
|
|
FvImageSectionObj.FvFileName = FvName
|
|
|
|
Obj.SectionList.append(FvImageSectionObj)
|
|
|
|
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()
|
|
DepexSectionObj.Alignment = AlignValue
|
|
DepexSectionObj.DepexType = self._Token
|
|
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
if not self._IsToken("{"):
|
|
raise Warning.ExpectedCurlyOpen(self.FileName, self.CurrentLineNumber)
|
|
if not self._SkipToToken(T_CHAR_BRACE_R):
|
|
raise Warning.Expected("Depex expression ending '}'", self.FileName, self.CurrentLineNumber)
|
|
|
|
DepexSectionObj.Expression = self._SkippedChars.rstrip(T_CHAR_BRACE_R)
|
|
Obj.SectionList.append(DepexSectionObj)
|
|
|
|
else:
|
|
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":
|
|
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,\
|
|
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("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber)
|
|
|
|
# DataSection
|
|
DataSectionObj = DataSection()
|
|
DataSectionObj.Alignment = AlignValue
|
|
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':
|
|
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(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)
|
|
else:
|
|
if not self._GetCglSection(DataSectionObj):
|
|
return False
|
|
|
|
Obj.SectionList.append(DataSectionObj)
|
|
|
|
return True
|
|
|
|
## _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(TAB_WORKSPACE, '').find('$') != -1:
|
|
return
|
|
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
|
|
#
|
|
# Get compressed or GUIDed section for Obj
|
|
#
|
|
# @param self The object pointer
|
|
# @param Obj for whom leaf section is got
|
|
# @param AlignValue alignment value for complex section
|
|
# @retval True Successfully find section statement
|
|
# @retval False Not able to find section statement
|
|
#
|
|
def _GetCglSection(self, Obj, AlignValue = None):
|
|
|
|
if self._IsKeyword("COMPRESS"):
|
|
type = "PI_STD"
|
|
if self._IsKeyword("PI_STD") or self._IsKeyword("PI_NONE"):
|
|
type = self._Token
|
|
|
|
if not self._IsToken("{"):
|
|
raise Warning.ExpectedCurlyOpen(self.FileName, self.CurrentLineNumber)
|
|
|
|
CompressSectionObj = CompressSection()
|
|
CompressSectionObj.Alignment = AlignValue
|
|
CompressSectionObj.CompType = type
|
|
# Recursive sections...
|
|
while True:
|
|
IsLeafSection = self._GetLeafSection(CompressSectionObj)
|
|
IsEncapSection = self._GetEncapsulationSec(CompressSectionObj)
|
|
if not IsLeafSection and not IsEncapSection:
|
|
break
|
|
|
|
|
|
if not self._IsToken(T_CHAR_BRACE_R):
|
|
raise Warning.ExpectedCurlyClose(self.FileName, self.CurrentLineNumber)
|
|
Obj.SectionList.append(CompressSectionObj)
|
|
return True
|
|
|
|
elif self._IsKeyword("GUIDED"):
|
|
GuidValue = None
|
|
if self._GetNextGuid():
|
|
if self._Token in GlobalData.gGuidDict:
|
|
self._Token = GuidStructureStringToGuidString(GlobalData.gGuidDict[self._Token]).upper()
|
|
GuidValue = self._Token
|
|
|
|
AttribDict = self._GetGuidAttrib()
|
|
if not self._IsToken("{"):
|
|
raise Warning.ExpectedCurlyOpen(self.FileName, self.CurrentLineNumber)
|
|
GuidSectionObj = GuidSection()
|
|
GuidSectionObj.Alignment = AlignValue
|
|
GuidSectionObj.NameGuid = GuidValue
|
|
GuidSectionObj.SectionType = "GUIDED"
|
|
GuidSectionObj.ProcessRequired = AttribDict["PROCESSING_REQUIRED"]
|
|
GuidSectionObj.AuthStatusValid = AttribDict["AUTH_STATUS_VALID"]
|
|
GuidSectionObj.ExtraHeaderSize = AttribDict["EXTRA_HEADER_SIZE"]
|
|
# Recursive sections...
|
|
while True:
|
|
IsLeafSection = self._GetLeafSection(GuidSectionObj)
|
|
IsEncapSection = self._GetEncapsulationSec(GuidSectionObj)
|
|
if not IsLeafSection and not IsEncapSection:
|
|
break
|
|
|
|
if not self._IsToken(T_CHAR_BRACE_R):
|
|
raise Warning.ExpectedCurlyClose(self.FileName, self.CurrentLineNumber)
|
|
Obj.SectionList.append(GuidSectionObj)
|
|
|
|
return True
|
|
|
|
return False
|
|
|
|
## _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):
|
|
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
|
|
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
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":
|
|
Base = 16
|
|
try:
|
|
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"}:
|
|
raise Warning.Expected("TRUE/FALSE (1/0)", self.FileName, self.CurrentLineNumber)
|
|
AttribDict[AttribKey] = self._Token
|
|
|
|
return AttribDict
|
|
|
|
## _GetEncapsulationSec() method
|
|
#
|
|
# Get encapsulation section for FILE
|
|
#
|
|
# @param self The object pointer
|
|
# @param FfsFile for whom section is got
|
|
# @retval True Successfully find section statement
|
|
# @retval False Not able to find section statement
|
|
#
|
|
def _GetEncapsulationSec(self, FfsFileObj):
|
|
OldPos = self.GetFileBufferPos()
|
|
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 ALIGNMENT_NOAUTO:
|
|
raise Warning("Incorrect alignment '%s'" % self._Token, self.FileName, self.CurrentLineNumber)
|
|
AlignValue = self._Token
|
|
|
|
if not self._GetCglSection(FfsFileObj, AlignValue):
|
|
self.SetFileBufferPos(OldPos)
|
|
return False
|
|
else:
|
|
return True
|
|
|
|
def _GetFmp(self):
|
|
if not self._GetNextToken():
|
|
return False
|
|
S = self._Token.upper()
|
|
if S.startswith(TAB_SECTION_START) and not S.startswith("[FMPPAYLOAD."):
|
|
self.SectionParser(S)
|
|
self._UndoToken()
|
|
return False
|
|
|
|
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 = CapsulePayload()
|
|
FmpData.UiName = FmpUiName
|
|
|
|
if not self._IsToken(TAB_SECTION_END):
|
|
raise Warning.ExpectedBracketClose(self.FileName, self.CurrentLineNumber)
|
|
|
|
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
|
|
FmpKeyList.remove(Name)
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
if Name == 'IMAGE_TYPE_ID':
|
|
if not self._GetNextGuid():
|
|
raise Warning.Expected("GUID value for IMAGE_TYPE_ID.", self.FileName, self.CurrentLineNumber)
|
|
FmpData.ImageTypeId = self._Token
|
|
elif Name == 'CERTIFICATE_GUID':
|
|
if not self._GetNextGuid():
|
|
raise Warning.Expected("GUID value for CERTIFICATE_GUID.", self.FileName, self.CurrentLineNumber)
|
|
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():
|
|
raise Warning.Expected("value of %s" % Name, self.FileName, self.CurrentLineNumber)
|
|
Value = self._Token
|
|
if Name == 'IMAGE_HEADER_INIT_VERSION':
|
|
if FdfParser._Verify(Name, Value, 'UINT8'):
|
|
FmpData.Version = Value
|
|
elif Name == 'IMAGE_INDEX':
|
|
if FdfParser._Verify(Name, Value, 'UINT8'):
|
|
FmpData.ImageIndex = Value
|
|
elif Name == 'HARDWARE_INSTANCE':
|
|
if FdfParser._Verify(Name, Value, 'UINT8'):
|
|
FmpData.HardwareInstance = Value
|
|
elif Name == 'MONOTONIC_COUNT':
|
|
if FdfParser._Verify(Name, Value, 'UINT64'):
|
|
FmpData.MonotonicCount = Value
|
|
if FmpData.MonotonicCount.upper().startswith('0X'):
|
|
FmpData.MonotonicCount = int(FmpData.MonotonicCount, 16)
|
|
else:
|
|
FmpData.MonotonicCount = int(FmpData.MonotonicCount)
|
|
if not self._GetNextToken():
|
|
break
|
|
else:
|
|
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.")
|
|
|
|
# Only the IMAGE_TYPE_ID is required item
|
|
if FmpKeyList and 'IMAGE_TYPE_ID' in FmpKeyList:
|
|
raise Warning("'IMAGE_TYPE_ID' in FMP payload section.", self.FileName, self.CurrentLineNumber)
|
|
# get the Image file and Vendor code file
|
|
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
|
|
if len(FmpData.VendorCodeFile) > 1:
|
|
raise Warning("Vendor code file max of 1 per FMP payload section.", self.FileName, self.CurrentLineNumber)
|
|
self.Profile.FmpPayloadDict[FmpUiName] = FmpData
|
|
return True
|
|
|
|
## _GetCapsule() method
|
|
#
|
|
# Get capsule section contents and store its data into capsule list of self.Profile
|
|
#
|
|
# @param self The object pointer
|
|
# @retval True Successfully find a capsule
|
|
# @retval False Not able to find a capsule
|
|
#
|
|
def _GetCapsule(self):
|
|
if not self._GetNextToken():
|
|
return False
|
|
|
|
S = self._Token.upper()
|
|
if S.startswith(TAB_SECTION_START) and not S.startswith("[CAPSULE."):
|
|
self.SectionParser(S)
|
|
self._UndoToken()
|
|
return False
|
|
|
|
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)
|
|
raise Warning.Expected("[Capsule.]", self.FileName, self.CurrentLineNumber)
|
|
|
|
CapsuleObj = Capsule()
|
|
|
|
CapsuleName = self._GetUiName()
|
|
if not CapsuleName:
|
|
raise Warning.Expected("capsule name", self.FileName, self.CurrentLineNumber)
|
|
|
|
CapsuleObj.UiCapsuleName = CapsuleName.upper()
|
|
|
|
if not self._IsToken(TAB_SECTION_END):
|
|
raise Warning.ExpectedBracketClose(self.FileName, self.CurrentLineNumber)
|
|
|
|
if self._IsKeyword("CREATE_FILE"):
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("file name", self.FileName, self.CurrentLineNumber)
|
|
|
|
CapsuleObj.CreateFile = self._Token
|
|
|
|
self._GetCapsuleStatements(CapsuleObj)
|
|
self.Profile.CapsuleDict[CapsuleObj.UiCapsuleName] = CapsuleObj
|
|
return True
|
|
|
|
## _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)
|
|
|
|
## _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():
|
|
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(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("value", self.FileName, self.CurrentLineNumber)
|
|
if Name == 'CAPSULE_FLAGS':
|
|
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(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"}:
|
|
raise Warning.Expected("PersistAcrossReset, PopulateSystemTable, or InitiateReset", self.FileName, self.CurrentLineNumber)
|
|
Value += self._Token.strip()
|
|
elif Name == 'OEM_CAPSULE_FLAGS':
|
|
Value = self._Token.strip()
|
|
if not Value.upper().startswith('0X'):
|
|
raise Warning.Expected("hex value starting with 0x", self.FileName, self.CurrentLineNumber)
|
|
try:
|
|
Value = int(Value, 0)
|
|
except ValueError:
|
|
raise Warning.Expected("hex string failed to convert to value", 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()
|
|
else:
|
|
Value = self._Token.strip()
|
|
Obj.TokensDict[Name] = Value
|
|
if not self._GetNextToken():
|
|
return False
|
|
self._UndoToken()
|
|
|
|
## _GetCapsuleData() method
|
|
#
|
|
# Get capsule data for capsule
|
|
#
|
|
# @param self The object pointer
|
|
# @param Obj for whom capsule data are got
|
|
#
|
|
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)
|
|
if not (IsInf or IsFile or IsFv or IsFd or IsAnyFile or IsAfile or IsFmp):
|
|
break
|
|
|
|
## _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):
|
|
while 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
|
|
#
|
|
# Get FV for capsule
|
|
#
|
|
# @param self The object pointer
|
|
# @param CapsuleObj for whom FV is got
|
|
# @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):
|
|
return False
|
|
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("FV name", self.FileName, self.CurrentLineNumber)
|
|
|
|
if self._Token.upper() not in self.Profile.FvDict:
|
|
raise Warning("FV name does not exist", self.FileName, self.CurrentLineNumber)
|
|
|
|
myCapsuleFv = CapsuleFv()
|
|
myCapsuleFv.FvName = self._Token
|
|
if FMPCapsule:
|
|
if not CapsuleObj.ImageFile:
|
|
CapsuleObj.ImageFile.append(myCapsuleFv)
|
|
else:
|
|
CapsuleObj.VendorCodeFile.append(myCapsuleFv)
|
|
else:
|
|
CapsuleObj.CapsuleDataList.append(myCapsuleFv)
|
|
return True
|
|
|
|
## _GetFdStatement() method
|
|
#
|
|
# Get FD for capsule
|
|
#
|
|
# @param self The object pointer
|
|
# @param CapsuleObj for whom FD is got
|
|
# @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"):
|
|
return False
|
|
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("FD name", self.FileName, self.CurrentLineNumber)
|
|
|
|
if self._Token.upper() not in self.Profile.FdDict:
|
|
raise Warning("FD name does not exist", self.FileName, self.CurrentLineNumber)
|
|
|
|
myCapsuleFd = CapsuleFd()
|
|
myCapsuleFd.FdName = self._Token
|
|
if FMPCapsule:
|
|
if not CapsuleObj.ImageFile:
|
|
CapsuleObj.ImageFile.append(myCapsuleFd)
|
|
else:
|
|
CapsuleObj.VendorCodeFile.append(myCapsuleFd)
|
|
else:
|
|
CapsuleObj.CapsuleDataList.append(myCapsuleFd)
|
|
return True
|
|
|
|
def _GetFmpStatement(self, CapsuleObj):
|
|
if not self._IsKeyword("FMP_PAYLOAD"):
|
|
if not self._IsKeyword("FMP"):
|
|
return False
|
|
|
|
if not self._IsKeyword("PAYLOAD"):
|
|
self._UndoToken()
|
|
return False
|
|
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("payload name after FMP_PAYLOAD =", self.FileName, self.CurrentLineNumber)
|
|
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)
|
|
CapsuleObj.FmpPayloadList.append(self.Profile.FmpPayloadDict[Payload])
|
|
return True
|
|
|
|
def _ParseRawFileStatement(self):
|
|
if not self._IsKeyword("FILE"):
|
|
return None
|
|
|
|
if not self._IsKeyword("DATA"):
|
|
self._UndoToken()
|
|
return None
|
|
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("File name", self.FileName, self.CurrentLineNumber)
|
|
|
|
AnyFileName = self._Token
|
|
self._VerifyFile(AnyFileName)
|
|
|
|
if not os.path.isabs(AnyFileName):
|
|
AnyFileName = mws.join(GenFdsGlobalVariable.WorkSpaceDir, AnyFileName)
|
|
|
|
return AnyFileName
|
|
|
|
## _GetAnyFileStatement() method
|
|
#
|
|
# Get AnyFile for capsule
|
|
#
|
|
# @param self The object pointer
|
|
# @param CapsuleObj for whom AnyFile is got
|
|
# @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()
|
|
if not AnyFileName:
|
|
return False
|
|
|
|
myCapsuleAnyFile = CapsuleAnyFile()
|
|
myCapsuleAnyFile.FileName = AnyFileName
|
|
if FMPCapsule:
|
|
if not CapsuleObj.ImageFile:
|
|
CapsuleObj.ImageFile.append(myCapsuleAnyFile)
|
|
else:
|
|
CapsuleObj.VendorCodeFile.append(myCapsuleAnyFile)
|
|
else:
|
|
CapsuleObj.CapsuleDataList.append(myCapsuleAnyFile)
|
|
return True
|
|
|
|
## _GetAfileStatement() method
|
|
#
|
|
# Get Afile for capsule
|
|
#
|
|
# @param self The object pointer
|
|
# @param CapsuleObj for whom Afile is got
|
|
# @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"):
|
|
return False
|
|
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("Afile name", self.FileName, self.CurrentLineNumber)
|
|
|
|
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"}:
|
|
raise Warning('invalid binary file type, should be one of "bin",BINARY_FILE_TYPE_BIN,"Bin","dat","DAT","Dat","data","DATA","Data"', \
|
|
self.FileName, self.CurrentLineNumber)
|
|
|
|
if not os.path.isabs(AfileName):
|
|
AfileName = GenFdsGlobalVariable.ReplaceWorkspaceMacro(AfileName)
|
|
self._VerifyFile(AfileName)
|
|
else:
|
|
if not os.path.exists(AfileName):
|
|
raise Warning('%s does not exist' % AfileName, self.FileName, self.CurrentLineNumber)
|
|
else:
|
|
pass
|
|
|
|
myCapsuleAfile = CapsuleAfile()
|
|
myCapsuleAfile.FileName = AfileName
|
|
CapsuleObj.CapsuleDataList.append(myCapsuleAfile)
|
|
return True
|
|
|
|
## _GetRule() method
|
|
#
|
|
# Get Rule section contents and store its data into rule list of self.Profile
|
|
#
|
|
# @param self The object pointer
|
|
# @retval True Successfully find a Rule
|
|
# @retval False Not able to find a Rule
|
|
#
|
|
def _GetRule(self):
|
|
if not self._GetNextToken():
|
|
return False
|
|
|
|
S = self._Token.upper()
|
|
if S.startswith(TAB_SECTION_START) and not S.startswith("[RULE."):
|
|
self.SectionParser(S)
|
|
self._UndoToken()
|
|
return False
|
|
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)
|
|
raise Warning.Expected("[Rule.]", self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._SkipToToken(TAB_SPLIT):
|
|
raise Warning.Expected("'.'", self.FileName, self.CurrentLineNumber)
|
|
|
|
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()
|
|
|
|
TemplateName = ""
|
|
if self._IsToken(TAB_SPLIT):
|
|
if not self._GetNextWord():
|
|
raise Warning.Expected("template name", self.FileName, self.CurrentLineNumber)
|
|
TemplateName = self._Token
|
|
|
|
if not self._IsToken(TAB_SECTION_END):
|
|
raise Warning.ExpectedBracketClose(self.FileName, self.CurrentLineNumber)
|
|
|
|
RuleObj = self._GetRuleFileStatements()
|
|
RuleObj.Arch = Arch.upper()
|
|
RuleObj.ModuleType = ModuleType
|
|
RuleObj.TemplateName = TemplateName
|
|
if TemplateName == '':
|
|
self.Profile.RuleDict['RULE' + \
|
|
TAB_SPLIT + \
|
|
Arch.upper() + \
|
|
TAB_SPLIT + \
|
|
ModuleType.upper() ] = RuleObj
|
|
else:
|
|
self.Profile.RuleDict['RULE' + \
|
|
TAB_SPLIT + \
|
|
Arch.upper() + \
|
|
TAB_SPLIT + \
|
|
ModuleType.upper() + \
|
|
TAB_SPLIT + \
|
|
TemplateName.upper() ] = RuleObj
|
|
return True
|
|
|
|
## _GetModuleType() method
|
|
#
|
|
# Return the module type
|
|
#
|
|
# @param self The object pointer
|
|
# @retval string module type
|
|
#
|
|
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, 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, SUP_MODULE_HOST_APPLICATION,
|
|
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
|
|
|
|
## _GetFileExtension() method
|
|
#
|
|
# Return the file extension
|
|
#
|
|
# @param self The object pointer
|
|
# @retval string file name extension
|
|
#
|
|
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 TAB_SPLIT + Ext
|
|
else:
|
|
raise Warning("Unknown file extension '%s'" % self._Token, self.FileName, self.CurrentLineNumber)
|
|
|
|
else:
|
|
raise Warning.Expected("file extension", self.FileName, self.CurrentLineNumber)
|
|
|
|
## _GetRuleFileStatement() method
|
|
#
|
|
# Get rule contents
|
|
#
|
|
# @param self The object pointer
|
|
# @retval Rule Rule object
|
|
#
|
|
def _GetRuleFileStatements(self):
|
|
if not self._IsKeyword("FILE"):
|
|
raise Warning.Expected("FILE", self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._GetNextWord():
|
|
raise Warning.Expected("FFS type", self.FileName, self.CurrentLineNumber)
|
|
|
|
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)
|
|
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._IsKeyword("$(NAMED_GUID)"):
|
|
if not self._GetNextWord():
|
|
NamedGuid = self._CurrentLine()[self.CurrentOffsetWithinLine:].split()[0].strip()
|
|
if GlobalData.gGuidPatternEnd.match(NamedGuid):
|
|
self.CurrentOffsetWithinLine += len(NamedGuid)
|
|
self._Token = NamedGuid
|
|
else:
|
|
raise Warning.Expected("$(NAMED_GUID)", self.FileName, self.CurrentLineNumber)
|
|
if self._Token == 'PCD':
|
|
if not self._IsToken("("):
|
|
raise Warning.Expected("'('", self.FileName, self.CurrentLineNumber)
|
|
PcdPair = self._GetNextPcdSettings()
|
|
if not self._IsToken(")"):
|
|
raise Warning.Expected("')'", self.FileName, self.CurrentLineNumber)
|
|
self._Token = 'PCD('+PcdPair[1]+TAB_SPLIT+PcdPair[0]+')'
|
|
|
|
NameGuid = self._Token
|
|
|
|
KeepReloc = None
|
|
if self._IsKeyword('RELOCS_STRIPPED') or self._IsKeyword('RELOCS_RETAINED'):
|
|
if self._FileCouldHaveRelocFlag(Type):
|
|
if self._Token == 'RELOCS_STRIPPED':
|
|
KeepReloc = False
|
|
else:
|
|
KeepReloc = True
|
|
else:
|
|
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(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)
|
|
|
|
if not self._IsToken(TAB_COMMA_SPLIT):
|
|
break
|
|
|
|
else:
|
|
self._UndoToken()
|
|
|
|
|
|
Fixed = False
|
|
if self._IsKeyword("Fixed", True):
|
|
Fixed = True
|
|
|
|
CheckSum = False
|
|
if self._IsKeyword("CheckSum", True):
|
|
CheckSum = True
|
|
|
|
AlignValue = ""
|
|
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 self._IsToken("{"):
|
|
# Complex file rule expected
|
|
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:
|
|
NewRule.KeepReloc = KeepReloc
|
|
|
|
while True:
|
|
IsEncapsulate = self._GetRuleEncapsulationSection(NewRule)
|
|
IsLeaf = self._GetEfiSection(NewRule)
|
|
if not IsEncapsulate and not IsLeaf:
|
|
break
|
|
|
|
if not self._IsToken(T_CHAR_BRACE_R):
|
|
raise Warning.ExpectedCurlyClose(self.FileName, self.CurrentLineNumber)
|
|
|
|
return NewRule
|
|
|
|
else:
|
|
# Simple file rule expected
|
|
if not self._GetNextWord():
|
|
raise Warning.Expected("leaf section type", self.FileName, self.CurrentLineNumber)
|
|
|
|
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):
|
|
Fixed = True
|
|
|
|
if self._IsKeyword("CheckSum", True):
|
|
CheckSum = True
|
|
|
|
SectAlignment = ""
|
|
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
|
|
|
|
Ext = None
|
|
if self._IsToken(TAB_VALUE_SPLIT):
|
|
Ext = self._GetFileExtension()
|
|
elif not self._GetNextToken():
|
|
raise Warning.Expected("File name", self.FileName, self.CurrentLineNumber)
|
|
|
|
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:
|
|
NewRule.KeepReloc = KeepReloc
|
|
NewRule.FileExtension = Ext
|
|
NewRule.FileName = self._Token
|
|
return NewRule
|
|
|
|
## _GetEfiSection() method
|
|
#
|
|
# Get section list for Rule
|
|
#
|
|
# @param self The object pointer
|
|
# @param Obj for whom section is got
|
|
# @retval True Successfully find section statement
|
|
# @retval False Not able to find section statement
|
|
#
|
|
def _GetEfiSection(self, Obj):
|
|
OldPos = self.GetFileBufferPos()
|
|
EfiSectionObj = EfiSection()
|
|
if not self._GetNextWord():
|
|
CurrentLine = self._CurrentLine()[self.CurrentOffsetWithinLine:].split()[0].strip()
|
|
if self._Token == '{' and Obj.FvFileType == "RAW" and TAB_SPLIT in CurrentLine:
|
|
if self._IsToken(TAB_VALUE_SPLIT):
|
|
EfiSectionObj.FileExtension = self._GetFileExtension()
|
|
elif self._GetNextToken():
|
|
EfiSectionObj.FileName = self._Token
|
|
EfiSectionObj.SectionType = BINARY_FILE_TYPE_RAW
|
|
Obj.SectionList.append(EfiSectionObj)
|
|
return True
|
|
else:
|
|
return False
|
|
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, BINARY_FILE_TYPE_GUID}:
|
|
self._UndoToken()
|
|
return False
|
|
|
|
if SectionName == "FV_IMAGE":
|
|
FvImageSectionObj = FvImageSection()
|
|
if self._IsKeyword("FV_IMAGE"):
|
|
pass
|
|
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)
|
|
if not IsInf and not IsFile:
|
|
break
|
|
|
|
if not self._IsToken(T_CHAR_BRACE_R):
|
|
raise Warning.ExpectedCurlyClose(self.FileName, self.CurrentLineNumber)
|
|
FvImageSectionObj.Fv = FvObj
|
|
FvImageSectionObj.FvName = None
|
|
|
|
else:
|
|
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 ALIGNMENT_NOAUTO:
|
|
raise Warning("Incorrect alignment '%s'" % self._Token, self.FileName, self.CurrentLineNumber)
|
|
FvImageSectionObj.Alignment = self._Token
|
|
|
|
if self._IsToken(TAB_VALUE_SPLIT):
|
|
FvImageSectionObj.FvFileExtension = self._GetFileExtension()
|
|
elif self._GetNextToken():
|
|
if self._Token not in {
|
|
T_CHAR_BRACE_R, "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
|
|
else:
|
|
self._UndoToken()
|
|
else:
|
|
raise Warning.Expected("FV file name", self.FileName, self.CurrentLineNumber)
|
|
|
|
Obj.SectionList.append(FvImageSectionObj)
|
|
return True
|
|
|
|
EfiSectionObj.SectionType = SectionName
|
|
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("file type", self.FileName, self.CurrentLineNumber)
|
|
|
|
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(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("Quoted String", self.FileName, self.CurrentLineNumber)
|
|
|
|
if self._GetStringData():
|
|
EfiSectionObj.StringData = self._Token
|
|
|
|
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(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("Build number", self.FileName, self.CurrentLineNumber)
|
|
EfiSectionObj.BuildNum = self._Token
|
|
|
|
else:
|
|
EfiSectionObj.FileType = self._Token
|
|
self._CheckRuleSectionFileType(EfiSectionObj.SectionType, EfiSectionObj.FileType)
|
|
|
|
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):
|
|
raise Warning("%s section could NOT have BUILD_NUM%d" % (EfiSectionObj.SectionType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber)
|
|
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("Build number", self.FileName, self.CurrentLineNumber)
|
|
EfiSectionObj.BuildNum = self._Token
|
|
|
|
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
|
|
|
|
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
|
|
if Obj.KeepReloc is not None and Obj.KeepReloc != EfiSectionObj.KeepReloc:
|
|
raise Warning("Section type %s has reloc strip flag conflict with Rule" % EfiSectionObj.SectionType, self.FileName, self.CurrentLineNumber)
|
|
else:
|
|
raise Warning("Section type %s could not have reloc strip flag" % EfiSectionObj.SectionType, self.FileName, self.CurrentLineNumber)
|
|
|
|
|
|
if self._IsToken(TAB_VALUE_SPLIT):
|
|
EfiSectionObj.FileExtension = self._GetFileExtension()
|
|
elif self._GetNextToken():
|
|
if self._Token not in {
|
|
T_CHAR_BRACE_R, "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 == 'PCD':
|
|
if not self._IsToken("("):
|
|
raise Warning.Expected("'('", self.FileName, self.CurrentLineNumber)
|
|
PcdPair = self._GetNextPcdSettings()
|
|
if not self._IsToken(")"):
|
|
raise Warning.Expected("')'", self.FileName, self.CurrentLineNumber)
|
|
self._Token = 'PCD('+PcdPair[1]+TAB_SPLIT+PcdPair[0]+')'
|
|
|
|
EfiSectionObj.FileName = self._Token
|
|
|
|
else:
|
|
self._UndoToken()
|
|
else:
|
|
raise Warning.Expected("section file name", self.FileName, self.CurrentLineNumber)
|
|
|
|
Obj.SectionList.append(EfiSectionObj)
|
|
return True
|
|
|
|
## _RuleSectionCouldBeOptional() method
|
|
#
|
|
# Get whether a section could be optional
|
|
#
|
|
# @param SectionType The section type to check
|
|
# @retval True section could be optional
|
|
# @retval False section never optional
|
|
#
|
|
@staticmethod
|
|
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
|
|
#
|
|
# Get whether a section could have build number information
|
|
#
|
|
# @param SectionType The section type to check
|
|
# @retval True section could have build number information
|
|
# @retval False section never have build number information
|
|
#
|
|
@staticmethod
|
|
def _RuleSectionCouldHaveBuildNum(SectionType):
|
|
if SectionType == "VERSION":
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
## _RuleSectionCouldHaveString() method
|
|
#
|
|
# Get whether a section could have string
|
|
#
|
|
# @param SectionType The section type to check
|
|
# @retval True section could have string
|
|
# @retval False section never have string
|
|
#
|
|
@staticmethod
|
|
def _RuleSectionCouldHaveString(SectionType):
|
|
if SectionType in {BINARY_FILE_TYPE_UI, "VERSION"}:
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
## _CheckRuleSectionFileType() method
|
|
#
|
|
# Get whether a section matches a file type
|
|
#
|
|
# @param self The object pointer
|
|
# @param SectionType The section type to check
|
|
# @param FileType The file type to check
|
|
#
|
|
def _CheckRuleSectionFileType(self, SectionType, FileType):
|
|
WarningString = "Incorrect section file type '%s'"
|
|
if SectionType == "COMPAT16":
|
|
if FileType not in {"COMPAT16", "SEC_COMPAT16"}:
|
|
raise Warning(WarningString % FileType, self.FileName, self.CurrentLineNumber)
|
|
elif SectionType == BINARY_FILE_TYPE_PE32:
|
|
if FileType not in {BINARY_FILE_TYPE_PE32, "SEC_PE32"}:
|
|
raise Warning(WarningString % FileType, self.FileName, self.CurrentLineNumber)
|
|
elif SectionType == BINARY_FILE_TYPE_PIC:
|
|
if FileType not in {BINARY_FILE_TYPE_PIC, BINARY_FILE_TYPE_PIC}:
|
|
raise Warning(WarningString % FileType, self.FileName, self.CurrentLineNumber)
|
|
elif SectionType == BINARY_FILE_TYPE_TE:
|
|
if FileType not in {BINARY_FILE_TYPE_TE, "SEC_TE"}:
|
|
raise Warning(WarningString % FileType, self.FileName, self.CurrentLineNumber)
|
|
elif SectionType == "RAW":
|
|
if FileType not in {BINARY_FILE_TYPE_BIN, "SEC_BIN", "RAW", "ASL", "ACPI"}:
|
|
raise Warning(WarningString % FileType, self.FileName, self.CurrentLineNumber)
|
|
elif SectionType == BINARY_FILE_TYPE_DXE_DEPEX or SectionType == BINARY_FILE_TYPE_SMM_DEPEX:
|
|
if FileType not in {BINARY_FILE_TYPE_DXE_DEPEX, "SEC_DXE_DEPEX", BINARY_FILE_TYPE_SMM_DEPEX}:
|
|
raise Warning(WarningString % FileType, self.FileName, self.CurrentLineNumber)
|
|
elif SectionType == BINARY_FILE_TYPE_UI:
|
|
if FileType not in {BINARY_FILE_TYPE_UI, "SEC_UI"}:
|
|
raise Warning(WarningString % FileType, self.FileName, self.CurrentLineNumber)
|
|
elif SectionType == "VERSION":
|
|
if FileType not in {"VERSION", "SEC_VERSION"}:
|
|
raise Warning(WarningString % FileType, self.FileName, self.CurrentLineNumber)
|
|
elif SectionType == BINARY_FILE_TYPE_PEI_DEPEX:
|
|
if FileType not in {BINARY_FILE_TYPE_PEI_DEPEX, "SEC_PEI_DEPEX"}:
|
|
raise Warning(WarningString % FileType, self.FileName, self.CurrentLineNumber)
|
|
elif SectionType == BINARY_FILE_TYPE_GUID:
|
|
if FileType not in {BINARY_FILE_TYPE_PE32, "SEC_GUID"}:
|
|
raise Warning(WarningString % FileType, self.FileName, self.CurrentLineNumber)
|
|
|
|
## _GetRuleEncapsulationSection() method
|
|
#
|
|
# Get encapsulation section for Rule
|
|
#
|
|
# @param self The object pointer
|
|
# @param theRule for whom section is got
|
|
# @retval True Successfully find section statement
|
|
# @retval False Not able to find section statement
|
|
#
|
|
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 not self._IsToken("{"):
|
|
raise Warning.ExpectedCurlyOpen(self.FileName, self.CurrentLineNumber)
|
|
|
|
CompressSectionObj = CompressSection()
|
|
|
|
CompressSectionObj.CompType = Type
|
|
# Recursive sections...
|
|
while True:
|
|
IsEncapsulate = self._GetRuleEncapsulationSection(CompressSectionObj)
|
|
IsLeaf = self._GetEfiSection(CompressSectionObj)
|
|
if not IsEncapsulate and not IsLeaf:
|
|
break
|
|
|
|
if not self._IsToken(T_CHAR_BRACE_R):
|
|
raise Warning.ExpectedCurlyClose(self.FileName, self.CurrentLineNumber)
|
|
theRule.SectionList.append(CompressSectionObj)
|
|
|
|
return True
|
|
|
|
elif self._IsKeyword("GUIDED"):
|
|
GuidValue = None
|
|
if self._GetNextGuid():
|
|
if self._Token in GlobalData.gGuidDict:
|
|
self._Token = GuidStructureStringToGuidString(GlobalData.gGuidDict[self._Token]).upper()
|
|
GuidValue = self._Token
|
|
|
|
if self._IsKeyword("$(NAMED_GUID)"):
|
|
GuidValue = self._Token
|
|
|
|
AttribDict = self._GetGuidAttrib()
|
|
|
|
if not self._IsToken("{"):
|
|
raise Warning.ExpectedCurlyOpen(self.FileName, self.CurrentLineNumber)
|
|
GuidSectionObj = GuidSection()
|
|
GuidSectionObj.NameGuid = GuidValue
|
|
GuidSectionObj.SectionType = "GUIDED"
|
|
GuidSectionObj.ProcessRequired = AttribDict["PROCESSING_REQUIRED"]
|
|
GuidSectionObj.AuthStatusValid = AttribDict["AUTH_STATUS_VALID"]
|
|
GuidSectionObj.ExtraHeaderSize = AttribDict["EXTRA_HEADER_SIZE"]
|
|
|
|
# Efi sections...
|
|
while True:
|
|
IsEncapsulate = self._GetRuleEncapsulationSection(GuidSectionObj)
|
|
IsLeaf = self._GetEfiSection(GuidSectionObj)
|
|
if not IsEncapsulate and not IsLeaf:
|
|
break
|
|
|
|
if not self._IsToken(T_CHAR_BRACE_R):
|
|
raise Warning.ExpectedCurlyClose(self.FileName, self.CurrentLineNumber)
|
|
theRule.SectionList.append(GuidSectionObj)
|
|
|
|
return True
|
|
|
|
return False
|
|
|
|
## _GetOptionRom() method
|
|
#
|
|
# Get OptionROM section contents and store its data into OptionROM list of self.Profile
|
|
#
|
|
# @param self The object pointer
|
|
# @retval True Successfully find a OptionROM
|
|
# @retval False Not able to find a OptionROM
|
|
#
|
|
def _GetOptionRom(self):
|
|
if not self._GetNextToken():
|
|
return False
|
|
|
|
S = self._Token.upper()
|
|
if S.startswith(TAB_SECTION_START) and not S.startswith("[OPTIONROM."):
|
|
self.SectionParser(S)
|
|
self._UndoToken()
|
|
return False
|
|
|
|
self._UndoToken()
|
|
if not self._IsToken("[OptionRom.", True):
|
|
raise Warning("Unknown Keyword '%s'" % self._Token, self.FileName, self.CurrentLineNumber)
|
|
|
|
OptRomName = self._GetUiName()
|
|
|
|
if not self._IsToken(TAB_SECTION_END):
|
|
raise Warning.ExpectedBracketClose(self.FileName, self.CurrentLineNumber)
|
|
|
|
OptRomObj = OPTIONROM(OptRomName)
|
|
self.Profile.OptRomDict[OptRomName] = OptRomObj
|
|
|
|
while True:
|
|
isInf = self._GetOptRomInfStatement(OptRomObj)
|
|
isFile = self._GetOptRomFileStatement(OptRomObj)
|
|
if not isInf and not isFile:
|
|
break
|
|
|
|
return True
|
|
|
|
## _GetOptRomInfStatement() method
|
|
#
|
|
# Get INF statements
|
|
#
|
|
# @param self The object pointer
|
|
# @param Obj for whom inf statement is got
|
|
# @retval True Successfully find inf statement
|
|
# @retval False Not able to find inf statement
|
|
#
|
|
def _GetOptRomInfStatement(self, Obj):
|
|
if not self._IsKeyword("INF"):
|
|
return False
|
|
|
|
ffsInf = OptRomInfStatement()
|
|
self._GetInfOptions(ffsInf)
|
|
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("INF file path", self.FileName, self.CurrentLineNumber)
|
|
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:
|
|
EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo)
|
|
|
|
NewFileName = ffsInf.InfFileName
|
|
if ffsInf.OverrideGuid:
|
|
NewFileName = ProcessDuplicatedInf(PathClass(ffsInf.InfFileName,GenFdsGlobalVariable.WorkSpaceDir), ffsInf.OverrideGuid, GenFdsGlobalVariable.WorkSpaceDir).Path
|
|
|
|
if not NewFileName in self.Profile.InfList:
|
|
self.Profile.InfList.append(NewFileName)
|
|
FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)
|
|
self.Profile.InfFileLineList.append(FileLineTuple)
|
|
if ffsInf.UseArch:
|
|
if ffsInf.UseArch not in self.Profile.InfDict:
|
|
self.Profile.InfDict[ffsInf.UseArch] = [ffsInf.InfFileName]
|
|
else:
|
|
self.Profile.InfDict[ffsInf.UseArch].append(ffsInf.InfFileName)
|
|
else:
|
|
self.Profile.InfDict['ArchTBD'].append(ffsInf.InfFileName)
|
|
|
|
|
|
self._GetOptRomOverrides (ffsInf)
|
|
|
|
Obj.FfsList.append(ffsInf)
|
|
return True
|
|
|
|
## _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 = OverrideAttribs()
|
|
while True:
|
|
if self._IsKeyword("PCI_VENDOR_ID"):
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
if not self._GetNextHexNumber():
|
|
raise Warning.Expected("Hex vendor id", self.FileName, self.CurrentLineNumber)
|
|
Overrides.PciVendorId = self._Token
|
|
continue
|
|
|
|
if self._IsKeyword("PCI_CLASS_CODE"):
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
if not self._GetNextHexNumber():
|
|
raise Warning.Expected("Hex class code", self.FileName, self.CurrentLineNumber)
|
|
Overrides.PciClassCode = self._Token
|
|
continue
|
|
|
|
if self._IsKeyword("PCI_DEVICE_ID"):
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
# Get a list of PCI IDs
|
|
Overrides.PciDeviceId = ""
|
|
while (self._GetNextHexNumber()):
|
|
Overrides.PciDeviceId = "{} {}".format(Overrides.PciDeviceId, self._Token)
|
|
if not Overrides.PciDeviceId:
|
|
raise Warning.Expected("one or more Hex device ids", self.FileName, self.CurrentLineNumber)
|
|
continue
|
|
|
|
if self._IsKeyword("PCI_REVISION"):
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
if not self._GetNextHexNumber():
|
|
raise Warning.Expected("Hex revision", self.FileName, self.CurrentLineNumber)
|
|
Overrides.PciRevision = self._Token
|
|
continue
|
|
|
|
if self._IsKeyword("PCI_COMPRESS"):
|
|
if not self._IsToken(TAB_EQUAL_SPLIT):
|
|
raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("TRUE/FALSE for compress", self.FileName, self.CurrentLineNumber)
|
|
Overrides.NeedCompress = self._Token.upper() == 'TRUE'
|
|
continue
|
|
|
|
if self._IsToken(T_CHAR_BRACE_R):
|
|
break
|
|
else:
|
|
EdkLogger.error("FdfParser", FORMAT_INVALID, File=self.FileName, Line=self.CurrentLineNumber)
|
|
|
|
Obj.OverrideAttribs = Overrides
|
|
|
|
## _GetOptRomFileStatement() method
|
|
#
|
|
# Get FILE statements
|
|
#
|
|
# @param self The object pointer
|
|
# @param Obj for whom FILE statement is got
|
|
# @retval True Successfully find FILE statement
|
|
# @retval False Not able to find FILE statement
|
|
#
|
|
def _GetOptRomFileStatement(self, Obj):
|
|
if not self._IsKeyword("FILE"):
|
|
return False
|
|
|
|
FfsFileObj = OptRomFileStatement()
|
|
|
|
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
|
|
|
|
if not self._GetNextToken():
|
|
raise Warning.Expected("File path", self.FileName, self.CurrentLineNumber)
|
|
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)
|
|
|
|
Obj.FfsList.append(FfsFileObj)
|
|
|
|
return True
|
|
|
|
## _GetCapInFd() method
|
|
#
|
|
# Get Cap list contained in FD
|
|
#
|
|
# @param self The object pointer
|
|
# @param FdName FD name
|
|
# @retval CapList List of Capsule in FD
|
|
#
|
|
def _GetCapInFd (self, FdName):
|
|
CapList = []
|
|
if FdName.upper() in self.Profile.FdDict:
|
|
FdObj = self.Profile.FdDict[FdName.upper()]
|
|
for elementRegion in FdObj.RegionList:
|
|
if elementRegion.RegionType == 'CAPSULE':
|
|
for elementRegionData in elementRegion.RegionDataList:
|
|
if elementRegionData.endswith(".cap"):
|
|
continue
|
|
if elementRegionData is not None and elementRegionData.upper() not in CapList:
|
|
CapList.append(elementRegionData.upper())
|
|
return CapList
|
|
|
|
## _GetReferencedFdCapTuple() method
|
|
#
|
|
# Get FV and FD list referenced by a capsule image
|
|
#
|
|
# @param self The object pointer
|
|
# @param CapObj Capsule section to be searched
|
|
# @param RefFdList referenced FD by section
|
|
# @param RefFvList referenced FV by section
|
|
#
|
|
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, 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)
|
|
|
|
## _GetFvInFd() method
|
|
#
|
|
# Get FV list contained in FD
|
|
#
|
|
# @param self The object pointer
|
|
# @param FdName FD name
|
|
# @retval FvList list of FV in FD
|
|
#
|
|
def _GetFvInFd (self, FdName):
|
|
FvList = []
|
|
if FdName.upper() in self.Profile.FdDict:
|
|
FdObj = self.Profile.FdDict[FdName.upper()]
|
|
for elementRegion in FdObj.RegionList:
|
|
if elementRegion.RegionType == BINARY_FILE_TYPE_FV:
|
|
for elementRegionData in elementRegion.RegionDataList:
|
|
if elementRegionData.endswith(".fv"):
|
|
continue
|
|
if elementRegionData is not None and elementRegionData.upper() not in FvList:
|
|
FvList.append(elementRegionData.upper())
|
|
return FvList
|
|
|
|
## _GetReferencedFdFvTuple() method
|
|
#
|
|
# Get FD and FV list referenced by a FFS file
|
|
#
|
|
# @param self The object pointer
|
|
# @param FfsFile contains sections to be searched
|
|
# @param RefFdList referenced FD by section
|
|
# @param RefFvList referenced FV by section
|
|
#
|
|
def _GetReferencedFdFvTuple(self, FvObj, RefFdList = [], RefFvList = []):
|
|
for FfsObj in FvObj.FfsList:
|
|
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)
|
|
|
|
## _GetReferencedFdFvTupleFromSection() method
|
|
#
|
|
# Get FD and FV list referenced by a FFS section
|
|
#
|
|
# @param self The object pointer
|
|
# @param FfsFile contains sections to be searched
|
|
# @param FdList referenced FD by section
|
|
# @param FvList referenced FV by section
|
|
#
|
|
def _GetReferencedFdFvTupleFromSection(self, FfsFile, FdList = [], FvList = []):
|
|
SectionStack = list(FfsFile.SectionList)
|
|
while SectionStack != []:
|
|
SectionObj = SectionStack.pop()
|
|
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)
|
|
|
|
if isinstance(SectionObj, CompressSection) or isinstance(SectionObj, GuidSection):
|
|
SectionStack.extend(SectionObj.SectionList)
|
|
|
|
## CycleReferenceCheck() method
|
|
#
|
|
# Check whether cycle reference exists in FDF
|
|
#
|
|
# @param self The object pointer
|
|
# @retval True cycle reference exists
|
|
# @retval False Not exists cycle reference
|
|
#
|
|
def CycleReferenceCheck(self):
|
|
#
|
|
# Check the cycle between FV and FD image
|
|
#
|
|
MaxLength = len (self.Profile.FvDict)
|
|
for FvName in self.Profile.FvDict:
|
|
LogStr = "\nCycle Reference Checking for FV: %s\n" % FvName
|
|
RefFvStack = set(FvName)
|
|
FdAnalyzedList = set()
|
|
|
|
Index = 0
|
|
while RefFvStack and Index < MaxLength:
|
|
Index = Index + 1
|
|
FvNameFromStack = RefFvStack.pop()
|
|
if FvNameFromStack.upper() in self.Profile.FvDict:
|
|
FvObj = self.Profile.FvDict[FvNameFromStack.upper()]
|
|
else:
|
|
continue
|
|
|
|
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)
|
|
if FvInFdList != []:
|
|
for FvNameInFd in FvInFdList:
|
|
LogStr += "FD %s contains FV %s\n" % (RefFdName, FvNameInFd)
|
|
if FvNameInFd not in RefFvStack:
|
|
RefFvStack.add(FvNameInFd)
|
|
|
|
if FvName in RefFvStack or FvNameFromStack in RefFvStack:
|
|
EdkLogger.info(LogStr)
|
|
return True
|
|
FdAnalyzedList.add(RefFdName)
|
|
|
|
for RefFvName in RefFvList:
|
|
LogStr += "FV %s contains FV %s\n" % (FvNameFromStack, RefFvName)
|
|
if RefFvName not in RefFvStack:
|
|
RefFvStack.add(RefFvName)
|
|
|
|
if FvName in RefFvStack or FvNameFromStack in RefFvStack:
|
|
EdkLogger.info(LogStr)
|
|
return True
|
|
|
|
#
|
|
# Check the cycle between Capsule and FD image
|
|
#
|
|
MaxLength = len (self.Profile.CapsuleDict)
|
|
for CapName in self.Profile.CapsuleDict:
|
|
#
|
|
# Capsule image to be checked.
|
|
#
|
|
LogStr = "\n\n\nCycle Reference Checking for Capsule: %s\n" % CapName
|
|
RefCapStack = {CapName}
|
|
FdAnalyzedList = set()
|
|
FvAnalyzedList = set()
|
|
|
|
Index = 0
|
|
while RefCapStack and Index < MaxLength:
|
|
Index = Index + 1
|
|
CapNameFromStack = RefCapStack.pop()
|
|
if CapNameFromStack.upper() in self.Profile.CapsuleDict:
|
|
CapObj = self.Profile.CapsuleDict[CapNameFromStack.upper()]
|
|
else:
|
|
continue
|
|
|
|
RefFvList = []
|
|
RefFdList = []
|
|
self._GetReferencedFdCapTuple(CapObj, RefFdList, RefFvList)
|
|
|
|
FvListLength = 0
|
|
FdListLength = 0
|
|
while FvListLength < len (RefFvList) or FdListLength < len (RefFdList):
|
|
for RefFdName in RefFdList:
|
|
if RefFdName in FdAnalyzedList:
|
|
continue
|
|
|
|
LogStr += "Capsule %s contains FD %s\n" % (CapNameFromStack, RefFdName)
|
|
for CapNameInFd in self._GetCapInFd(RefFdName):
|
|
LogStr += "FD %s contains Capsule %s\n" % (RefFdName, CapNameInFd)
|
|
if CapNameInFd not in RefCapStack:
|
|
RefCapStack.append(CapNameInFd)
|
|
|
|
if CapName in RefCapStack or CapNameFromStack in RefCapStack:
|
|
EdkLogger.info(LogStr)
|
|
return True
|
|
|
|
for FvNameInFd in self._GetFvInFd(RefFdName):
|
|
LogStr += "FD %s contains FV %s\n" % (RefFdName, FvNameInFd)
|
|
if FvNameInFd not in RefFvList:
|
|
RefFvList.append(FvNameInFd)
|
|
|
|
FdAnalyzedList.add(RefFdName)
|
|
#
|
|
# the number of the parsed FV and FD image
|
|
#
|
|
FvListLength = len (RefFvList)
|
|
FdListLength = len (RefFdList)
|
|
for RefFvName in RefFvList:
|
|
if RefFvName in FvAnalyzedList:
|
|
continue
|
|
LogStr += "Capsule %s contains FV %s\n" % (CapNameFromStack, RefFvName)
|
|
if RefFvName.upper() in self.Profile.FvDict:
|
|
FvObj = self.Profile.FvDict[RefFvName.upper()]
|
|
else:
|
|
continue
|
|
self._GetReferencedFdFvTuple(FvObj, RefFdList, RefFvList)
|
|
FvAnalyzedList.add(RefFvName)
|
|
|
|
return False
|
|
|
|
def GetAllIncludedFile (self):
|
|
global AllIncludeFileList
|
|
return AllIncludeFileList
|
|
|
|
if __name__ == "__main__":
|
|
import sys
|
|
try:
|
|
test_file = sys.argv[1]
|
|
except IndexError as v:
|
|
print("Usage: %s filename" % sys.argv[0])
|
|
sys.exit(1)
|
|
|
|
parser = FdfParser(test_file)
|
|
try:
|
|
parser.ParseFile()
|
|
parser.CycleReferenceCheck()
|
|
except Warning as X:
|
|
print(str(X))
|
|
else:
|
|
print("Success!")
|
|
|