421ccda307
1. Add a recovery mode for UPT failure 2. Add UNI file support 3. Add binary file header support 4. Add support for PCD error message 5. Add support for replace 6. Format generated INF/DEC files 7. Update dependency check 8. Other minor fixes Contributed-under: TianoCore Contribution Agreement 1.0 Signed-off-by: Hess Chen <hesheng.chen@intel.com> Reviewed-by: Gao, Liming <liming.gao@intel.com> git-svn-id: https://svn.code.sf.net/p/edk2/code/trunk/edk2@15896 6f19259b-4bc3-4df7-8a09-765794883524
693 lines
33 KiB
Python
693 lines
33 KiB
Python
## @file
|
|
# This file is used to define class objects of INF file [Binaries] section.
|
|
# It will consumed by InfParser.
|
|
#
|
|
# Copyright (c) 2011 - 2014, Intel Corporation. All rights reserved.<BR>
|
|
#
|
|
# This program and the accompanying materials are licensed and made available
|
|
# under the terms and conditions of the BSD License which accompanies this
|
|
# distribution. The full text of the license may be found at
|
|
# http://opensource.org/licenses/bsd-license.php
|
|
#
|
|
# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
|
|
|
'''
|
|
InfBinaryObject
|
|
'''
|
|
|
|
import os
|
|
|
|
from copy import deepcopy
|
|
from Library import DataType as DT
|
|
from Library import GlobalData
|
|
import Logger.Log as Logger
|
|
from Logger import ToolError
|
|
from Logger import StringTable as ST
|
|
from Library.Misc import Sdict
|
|
|
|
from Object.Parser.InfCommonObject import InfSectionCommonDef
|
|
from Object.Parser.InfCommonObject import CurrentLine
|
|
from Library.Misc import ConvPathFromAbsToRel
|
|
from Library.ExpressionValidate import IsValidFeatureFlagExp
|
|
from Library.Misc import ValidFile
|
|
from Library.ParserValidate import IsValidPath
|
|
|
|
|
|
class InfBianryItem():
|
|
def __init__(self):
|
|
self.FileName = ''
|
|
self.Target = ''
|
|
self.FeatureFlagExp = ''
|
|
self.HelpString = ''
|
|
self.Type = ''
|
|
self.SupArchList = []
|
|
|
|
def SetFileName(self, FileName):
|
|
self.FileName = FileName
|
|
def GetFileName(self):
|
|
return self.FileName
|
|
|
|
def SetTarget(self, Target):
|
|
self.Target = Target
|
|
def GetTarget(self):
|
|
return self.Target
|
|
|
|
def SetFeatureFlagExp(self, FeatureFlagExp):
|
|
self.FeatureFlagExp = FeatureFlagExp
|
|
def GetFeatureFlagExp(self):
|
|
return self.FeatureFlagExp
|
|
|
|
def SetHelpString(self, HelpString):
|
|
self.HelpString = HelpString
|
|
def GetHelpString(self):
|
|
return self.HelpString
|
|
|
|
def SetType(self, Type):
|
|
self.Type = Type
|
|
def GetType(self):
|
|
return self.Type
|
|
def SetSupArchList(self, SupArchList):
|
|
self.SupArchList = SupArchList
|
|
def GetSupArchList(self):
|
|
return self.SupArchList
|
|
|
|
class InfBianryVerItem(InfBianryItem, CurrentLine):
|
|
def __init__(self):
|
|
InfBianryItem.__init__(self)
|
|
CurrentLine.__init__(self)
|
|
self.VerTypeName = ''
|
|
|
|
def SetVerTypeName(self, VerTypeName):
|
|
self.VerTypeName = VerTypeName
|
|
def GetVerTypeName(self):
|
|
return self.VerTypeName
|
|
|
|
class InfBianryUiItem(InfBianryItem, CurrentLine):
|
|
def __init__(self):
|
|
InfBianryItem.__init__(self)
|
|
CurrentLine.__init__(self)
|
|
self.UiTypeName = ''
|
|
|
|
def SetUiTypeName(self, UiTypeName):
|
|
self.UiTypeName = UiTypeName
|
|
def GetVerTypeName(self):
|
|
return self.UiTypeName
|
|
|
|
class InfBianryCommonItem(InfBianryItem, CurrentLine):
|
|
def __init__(self):
|
|
self.CommonType = ''
|
|
self.TagName = ''
|
|
self.Family = ''
|
|
self.GuidValue = ''
|
|
InfBianryItem.__init__(self)
|
|
CurrentLine.__init__(self)
|
|
|
|
def SetCommonType(self, CommonType):
|
|
self.CommonType = CommonType
|
|
def GetCommonType(self):
|
|
return self.CommonType
|
|
|
|
def SetTagName(self, TagName):
|
|
self.TagName = TagName
|
|
def GetTagName(self):
|
|
return self.TagName
|
|
|
|
def SetFamily(self, Family):
|
|
self.Family = Family
|
|
def GetFamily(self):
|
|
return self.Family
|
|
|
|
def SetGuidValue(self, GuidValue):
|
|
self.GuidValue = GuidValue
|
|
def GetGuidValue(self):
|
|
return self.GuidValue
|
|
|
|
##
|
|
#
|
|
#
|
|
#
|
|
class InfBinariesObject(InfSectionCommonDef):
|
|
def __init__(self):
|
|
self.Binaries = Sdict()
|
|
#
|
|
# Macro defined in this section should be only used in this section.
|
|
#
|
|
self.Macros = {}
|
|
InfSectionCommonDef.__init__(self)
|
|
|
|
## CheckVer
|
|
#
|
|
#
|
|
def CheckVer(self, Ver, __SupArchList):
|
|
#
|
|
# Check Ver
|
|
#
|
|
for VerItem in Ver:
|
|
IsValidFileFlag = False
|
|
VerContent = VerItem[0]
|
|
VerComment = VerItem[1]
|
|
VerCurrentLine = VerItem[2]
|
|
GlobalData.gINF_CURRENT_LINE = VerCurrentLine
|
|
InfBianryVerItemObj = None
|
|
#
|
|
# Should not less than 2 elements
|
|
#
|
|
if len(VerContent) < 2:
|
|
Logger.Error("InfParser",
|
|
ToolError.FORMAT_INVALID,
|
|
ST.ERR_INF_PARSER_BINARY_ITEM_FORMAT_INVALID % (VerContent[0], 2),
|
|
File=VerCurrentLine.GetFileName(),
|
|
Line=VerCurrentLine.GetLineNo(),
|
|
ExtraData=VerCurrentLine.GetLineString())
|
|
return False
|
|
if len(VerContent) > 4:
|
|
Logger.Error("InfParser",
|
|
ToolError.FORMAT_INVALID,
|
|
ST.ERR_INF_PARSER_BINARY_ITEM_FORMAT_INVALID_MAX % (VerContent[0], 4),
|
|
File=VerCurrentLine.GetFileName(),
|
|
Line=VerCurrentLine.GetLineNo(),
|
|
ExtraData=VerCurrentLine.GetLineString())
|
|
return False
|
|
if len(VerContent) >= 2:
|
|
#
|
|
# Create a Ver Object.
|
|
#
|
|
InfBianryVerItemObj = InfBianryVerItem()
|
|
|
|
if VerContent[0] != DT.BINARY_FILE_TYPE_VER:
|
|
Logger.Error("InfParser",
|
|
ToolError.FORMAT_INVALID,
|
|
ST.ERR_INF_PARSER_BINARY_VER_TYPE % DT.BINARY_FILE_TYPE_VER,
|
|
File=VerCurrentLine.GetFileName(),
|
|
Line=VerCurrentLine.GetLineNo(),
|
|
ExtraData=VerCurrentLine.GetLineString())
|
|
|
|
InfBianryVerItemObj.SetVerTypeName(VerContent[0])
|
|
InfBianryVerItemObj.SetType(VerContent[0])
|
|
#
|
|
# Verify File exist or not
|
|
#
|
|
FullFileName = os.path.normpath(os.path.realpath(os.path.join(GlobalData.gINF_MODULE_DIR,
|
|
VerContent[1])))
|
|
if not (ValidFile(FullFileName) or ValidFile(VerContent[1])):
|
|
Logger.Error("InfParser",
|
|
ToolError.FORMAT_INVALID,
|
|
ST.ERR_INF_PARSER_BINARY_ITEM_FILE_NOT_EXIST % (VerContent[1]),
|
|
File=VerCurrentLine.GetFileName(),
|
|
Line=VerCurrentLine.GetLineNo(),
|
|
ExtraData=VerCurrentLine.GetLineString())
|
|
#
|
|
# Validate file exist/format.
|
|
#
|
|
if IsValidPath(VerContent[1], GlobalData.gINF_MODULE_DIR):
|
|
IsValidFileFlag = True
|
|
else:
|
|
Logger.Error("InfParser",
|
|
ToolError.FORMAT_INVALID,
|
|
ST.ERR_INF_PARSER_FILE_NOT_EXIST_OR_NAME_INVALID % (VerContent[1]),
|
|
File=VerCurrentLine.GetFileName(),
|
|
Line=VerCurrentLine.GetLineNo(),
|
|
ExtraData=VerCurrentLine.GetLineString())
|
|
return False
|
|
if IsValidFileFlag:
|
|
VerContent[0] = ConvPathFromAbsToRel(VerContent[0],
|
|
GlobalData.gINF_MODULE_DIR)
|
|
InfBianryVerItemObj.SetFileName(VerContent[1])
|
|
if len(VerContent) >= 3:
|
|
#
|
|
# Add Target information
|
|
#
|
|
InfBianryVerItemObj.SetTarget(VerContent[2])
|
|
if len(VerContent) == 4:
|
|
if VerContent[3].strip() == '':
|
|
Logger.Error("InfParser",
|
|
ToolError.FORMAT_INVALID,
|
|
ST.ERR_INF_PARSER_FEATURE_FLAG_EXP_MISSING,
|
|
File=VerCurrentLine.GetFileName(),
|
|
Line=VerCurrentLine.GetLineNo(),
|
|
ExtraData=VerCurrentLine.GetLineString())
|
|
#
|
|
# Validate Feature Flag Express
|
|
#
|
|
FeatureFlagRtv = IsValidFeatureFlagExp(VerContent[3].\
|
|
strip())
|
|
if not FeatureFlagRtv[0]:
|
|
Logger.Error("InfParser",
|
|
ToolError.FORMAT_INVALID,
|
|
ST.ERR_INF_PARSER_FEATURE_FLAG_EXP_SYNTAX_INVLID % (FeatureFlagRtv[1]),
|
|
File=VerCurrentLine.GetFileName(),
|
|
Line=VerCurrentLine.GetLineNo(),
|
|
ExtraData=VerCurrentLine.GetLineString())
|
|
InfBianryVerItemObj.SetFeatureFlagExp(VerContent[3])
|
|
|
|
InfBianryVerItemObj.SetSupArchList(__SupArchList)
|
|
|
|
#
|
|
# Determine binary file name duplicate. Follow below rule:
|
|
#
|
|
# A binary filename must not be duplicated within
|
|
# a [Binaries] section. A binary filename may appear in
|
|
# multiple architectural [Binaries] sections. A binary
|
|
# filename listed in an architectural [Binaries] section
|
|
# must not be listed in the common architectural
|
|
# [Binaries] section.
|
|
#
|
|
# NOTE: This check will not report error now.
|
|
#
|
|
for Item in self.Binaries:
|
|
if Item.GetFileName() == InfBianryVerItemObj.GetFileName():
|
|
ItemSupArchList = Item.GetSupArchList()
|
|
for ItemArch in ItemSupArchList:
|
|
for VerItemObjArch in __SupArchList:
|
|
if ItemArch == VerItemObjArch:
|
|
#
|
|
# ST.ERR_INF_PARSER_ITEM_DUPLICATE
|
|
#
|
|
pass
|
|
if ItemArch.upper() == 'COMMON' or VerItemObjArch.upper() == 'COMMON':
|
|
#
|
|
# ERR_INF_PARSER_ITEM_DUPLICATE_COMMON
|
|
#
|
|
pass
|
|
|
|
if InfBianryVerItemObj != None:
|
|
if self.Binaries.has_key((InfBianryVerItemObj)):
|
|
BinariesList = self.Binaries[InfBianryVerItemObj]
|
|
BinariesList.append((InfBianryVerItemObj, VerComment))
|
|
self.Binaries[InfBianryVerItemObj] = BinariesList
|
|
else:
|
|
BinariesList = []
|
|
BinariesList.append((InfBianryVerItemObj, VerComment))
|
|
self.Binaries[InfBianryVerItemObj] = BinariesList
|
|
|
|
## ParseCommonBinary
|
|
#
|
|
# ParseCommonBinary
|
|
#
|
|
def ParseCommonBinary(self, CommonBinary, __SupArchList):
|
|
#
|
|
# Check common binary definitions
|
|
# Type | FileName | Target | Family | TagName | FeatureFlagExp
|
|
#
|
|
for Item in CommonBinary:
|
|
IsValidFileFlag = False
|
|
ItemContent = Item[0]
|
|
ItemComment = Item[1]
|
|
CurrentLineOfItem = Item[2]
|
|
GlobalData.gINF_CURRENT_LINE = CurrentLineOfItem
|
|
InfBianryCommonItemObj = None
|
|
if ItemContent[0] == 'SUBTYPE_GUID':
|
|
if len(ItemContent) < 3:
|
|
Logger.Error("InfParser",
|
|
ToolError.FORMAT_INVALID,
|
|
ST.ERR_INF_PARSER_BINARY_ITEM_FORMAT_INVALID % (ItemContent[0], 3),
|
|
File=CurrentLineOfItem.GetFileName(),
|
|
Line=CurrentLineOfItem.GetLineNo(),
|
|
ExtraData=CurrentLineOfItem.GetLineString())
|
|
return False
|
|
else:
|
|
if len(ItemContent) < 2:
|
|
Logger.Error("InfParser",
|
|
ToolError.FORMAT_INVALID,
|
|
ST.ERR_INF_PARSER_BINARY_ITEM_FORMAT_INVALID % (ItemContent[0], 2),
|
|
File=CurrentLineOfItem.GetFileName(),
|
|
Line=CurrentLineOfItem.GetLineNo(),
|
|
ExtraData=CurrentLineOfItem.GetLineString())
|
|
return False
|
|
|
|
if len(ItemContent) > 7:
|
|
Logger.Error("InfParser",
|
|
ToolError.FORMAT_INVALID,
|
|
ST.ERR_INF_PARSER_BINARY_ITEM_FORMAT_INVALID_MAX % (ItemContent[0], 7),
|
|
File=CurrentLineOfItem.GetFileName(),
|
|
Line=CurrentLineOfItem.GetLineNo(),
|
|
ExtraData=CurrentLineOfItem.GetLineString())
|
|
return False
|
|
if len(ItemContent) >= 2:
|
|
#
|
|
# Create a Common Object.
|
|
#
|
|
InfBianryCommonItemObj = InfBianryCommonItem()
|
|
#
|
|
# Convert Binary type.
|
|
#
|
|
BinaryFileType = ItemContent[0].strip()
|
|
if BinaryFileType == 'RAW' or BinaryFileType == 'ACPI' or BinaryFileType == 'ASL':
|
|
BinaryFileType = 'BIN'
|
|
|
|
if BinaryFileType not in DT.BINARY_FILE_TYPE_LIST:
|
|
Logger.Error("InfParser",
|
|
ToolError.FORMAT_INVALID,
|
|
ST.ERR_INF_PARSER_BINARY_ITEM_INVALID_FILETYPE % \
|
|
(DT.BINARY_FILE_TYPE_LIST.__str__()),
|
|
File=CurrentLineOfItem.GetFileName(),
|
|
Line=CurrentLineOfItem.GetLineNo(),
|
|
ExtraData=CurrentLineOfItem.GetLineString())
|
|
|
|
if BinaryFileType == 'SUBTYPE_GUID':
|
|
BinaryFileType = 'FREEFORM'
|
|
|
|
if BinaryFileType == 'LIB' or BinaryFileType == 'UEFI_APP':
|
|
Logger.Error("InfParser",
|
|
ToolError.FORMAT_INVALID,
|
|
ST.ERR_INF_PARSER_BINARY_ITEM_INVALID_FILETYPE % \
|
|
(DT.BINARY_FILE_TYPE_LIST.__str__()),
|
|
File=CurrentLineOfItem.GetFileName(),
|
|
Line=CurrentLineOfItem.GetLineNo(),
|
|
ExtraData=CurrentLineOfItem.GetLineString())
|
|
|
|
InfBianryCommonItemObj.SetType(BinaryFileType)
|
|
InfBianryCommonItemObj.SetCommonType(ItemContent[0])
|
|
FileName = ''
|
|
if BinaryFileType == 'FREEFORM':
|
|
InfBianryCommonItemObj.SetGuidValue(ItemContent[1])
|
|
if len(ItemContent) >= 3:
|
|
FileName = ItemContent[2]
|
|
else:
|
|
Logger.Error("InfParser",
|
|
ToolError.FORMAT_INVALID,
|
|
ST.ERR_INF_PARSER_BINARY_ITEM_FILENAME_NOT_EXIST,
|
|
File=CurrentLineOfItem.GetFileName(),
|
|
Line=CurrentLineOfItem.GetLineNo(),
|
|
ExtraData=CurrentLineOfItem.GetLineString())
|
|
else:
|
|
FileName = ItemContent[1]
|
|
#
|
|
# Verify File exist or not
|
|
#
|
|
FullFileName = os.path.normpath(os.path.realpath(os.path.join(GlobalData.gINF_MODULE_DIR,
|
|
FileName)))
|
|
if not (ValidFile(FullFileName) or ValidFile(FileName)):
|
|
Logger.Error("InfParser",
|
|
ToolError.FORMAT_INVALID,
|
|
ST.ERR_INF_PARSER_BINARY_ITEM_FILE_NOT_EXIST % (FileName),
|
|
File=CurrentLineOfItem.GetFileName(),
|
|
Line=CurrentLineOfItem.GetLineNo(),
|
|
ExtraData=CurrentLineOfItem.GetLineString())
|
|
#
|
|
# Validate file exist/format.
|
|
#
|
|
if IsValidPath(FileName, GlobalData.gINF_MODULE_DIR):
|
|
IsValidFileFlag = True
|
|
else:
|
|
Logger.Error("InfParser",
|
|
ToolError.FORMAT_INVALID,
|
|
ST.ERR_INF_PARSER_FILE_NOT_EXIST_OR_NAME_INVALID % (FileName),
|
|
File=CurrentLineOfItem.GetFileName(),
|
|
Line=CurrentLineOfItem.GetLineNo(),
|
|
ExtraData=CurrentLineOfItem.GetLineString())
|
|
return False
|
|
if IsValidFileFlag:
|
|
ItemContent[0] = ConvPathFromAbsToRel(ItemContent[0], GlobalData.gINF_MODULE_DIR)
|
|
InfBianryCommonItemObj.SetFileName(FileName)
|
|
if len(ItemContent) >= 3:
|
|
#
|
|
# Add Target information
|
|
#
|
|
if BinaryFileType != 'FREEFORM':
|
|
InfBianryCommonItemObj.SetTarget(ItemContent[2])
|
|
|
|
if len(ItemContent) >= 4:
|
|
#
|
|
# Add Family information
|
|
#
|
|
if BinaryFileType != 'FREEFORM':
|
|
InfBianryCommonItemObj.SetFamily(ItemContent[3])
|
|
else:
|
|
InfBianryCommonItemObj.SetTarget(ItemContent[3])
|
|
|
|
if len(ItemContent) >= 5:
|
|
#
|
|
# TagName entries are build system specific. If there
|
|
# is content in the entry, the tool must exit
|
|
# gracefully with an error message that indicates build
|
|
# system specific content cannot be distributed using
|
|
# the UDP
|
|
#
|
|
if BinaryFileType != 'FREEFORM':
|
|
if ItemContent[4].strip() != '':
|
|
Logger.Error("InfParser",
|
|
ToolError.FORMAT_INVALID,
|
|
ST.ERR_INF_PARSER_TAGNAME_NOT_PERMITTED % (ItemContent[4]),
|
|
File=CurrentLineOfItem.GetFileName(),
|
|
Line=CurrentLineOfItem.GetLineNo(),
|
|
ExtraData=CurrentLineOfItem.GetLineString())
|
|
else:
|
|
InfBianryCommonItemObj.SetFamily(ItemContent[4])
|
|
|
|
if len(ItemContent) >= 6:
|
|
#
|
|
# Add FeatureFlagExp
|
|
#
|
|
if BinaryFileType != 'FREEFORM':
|
|
if ItemContent[5].strip() == '':
|
|
Logger.Error("InfParser",
|
|
ToolError.FORMAT_INVALID,
|
|
ST.ERR_INF_PARSER_FEATURE_FLAG_EXP_MISSING,
|
|
File=CurrentLineOfItem.GetFileName(),
|
|
Line=CurrentLineOfItem.GetLineNo(),
|
|
ExtraData=CurrentLineOfItem.GetLineString())
|
|
#
|
|
# Validate Feature Flag Express
|
|
#
|
|
FeatureFlagRtv = IsValidFeatureFlagExp(ItemContent[5].strip())
|
|
if not FeatureFlagRtv[0]:
|
|
Logger.Error("InfParser",
|
|
ToolError.FORMAT_INVALID,
|
|
ST.ERR_INF_PARSER_FEATURE_FLAG_EXP_SYNTAX_INVLID % (FeatureFlagRtv[1]),
|
|
File=CurrentLineOfItem.GetFileName(),
|
|
Line=CurrentLineOfItem.GetLineNo(),
|
|
ExtraData=CurrentLineOfItem.GetLineString())
|
|
InfBianryCommonItemObj.SetFeatureFlagExp(ItemContent[5])
|
|
else:
|
|
if ItemContent[5].strip() != '':
|
|
Logger.Error("InfParser",
|
|
ToolError.FORMAT_INVALID,
|
|
ST.ERR_INF_PARSER_TAGNAME_NOT_PERMITTED % (ItemContent[5]),
|
|
File=CurrentLineOfItem.GetFileName(),
|
|
Line=CurrentLineOfItem.GetLineNo(),
|
|
ExtraData=CurrentLineOfItem.GetLineString())
|
|
|
|
if len(ItemContent) == 7:
|
|
if ItemContent[6].strip() == '':
|
|
Logger.Error("InfParser",
|
|
ToolError.FORMAT_INVALID,
|
|
ST.ERR_INF_PARSER_FEATURE_FLAG_EXP_MISSING,
|
|
File=CurrentLineOfItem.GetFileName(),
|
|
Line=CurrentLineOfItem.GetLineNo(),
|
|
ExtraData=CurrentLineOfItem.GetLineString())
|
|
#
|
|
# Validate Feature Flag Express
|
|
#
|
|
FeatureFlagRtv = IsValidFeatureFlagExp(ItemContent[6].strip())
|
|
if not FeatureFlagRtv[0]:
|
|
Logger.Error("InfParser",
|
|
ToolError.FORMAT_INVALID,
|
|
ST.ERR_INF_PARSER_FEATURE_FLAG_EXP_SYNTAX_INVLID % (FeatureFlagRtv[1]),
|
|
File=CurrentLineOfItem.GetFileName(),
|
|
Line=CurrentLineOfItem.GetLineNo(),
|
|
ExtraData=CurrentLineOfItem.GetLineString())
|
|
InfBianryCommonItemObj.SetFeatureFlagExp(ItemContent[6])
|
|
|
|
InfBianryCommonItemObj.SetSupArchList(__SupArchList)
|
|
|
|
#
|
|
# Determine binary file name duplicate. Follow below rule:
|
|
#
|
|
# A binary filename must not be duplicated within
|
|
# a [Binaries] section. A binary filename may appear in
|
|
# multiple architectural [Binaries] sections. A binary
|
|
# filename listed in an architectural [Binaries] section
|
|
# must not be listed in the common architectural
|
|
# [Binaries] section.
|
|
#
|
|
# NOTE: This check will not report error now.
|
|
#
|
|
# for Item in self.Binaries:
|
|
# if Item.GetFileName() == InfBianryCommonItemObj.GetFileName():
|
|
# ItemSupArchList = Item.GetSupArchList()
|
|
# for ItemArch in ItemSupArchList:
|
|
# for ComItemObjArch in __SupArchList:
|
|
# if ItemArch == ComItemObjArch:
|
|
# #
|
|
# # ST.ERR_INF_PARSER_ITEM_DUPLICATE
|
|
# #
|
|
# pass
|
|
#
|
|
# if ItemArch.upper() == 'COMMON' or ComItemObjArch.upper() == 'COMMON':
|
|
# #
|
|
# # ERR_INF_PARSER_ITEM_DUPLICATE_COMMON
|
|
# #
|
|
# pass
|
|
|
|
if InfBianryCommonItemObj != None:
|
|
if self.Binaries.has_key((InfBianryCommonItemObj)):
|
|
BinariesList = self.Binaries[InfBianryCommonItemObj]
|
|
BinariesList.append((InfBianryCommonItemObj, ItemComment))
|
|
self.Binaries[InfBianryCommonItemObj] = BinariesList
|
|
else:
|
|
BinariesList = []
|
|
BinariesList.append((InfBianryCommonItemObj, ItemComment))
|
|
self.Binaries[InfBianryCommonItemObj] = BinariesList
|
|
|
|
def SetBinary(self, UiInf=None, Ver=None, CommonBinary=None, ArchList=None):
|
|
|
|
__SupArchList = []
|
|
for ArchItem in ArchList:
|
|
#
|
|
# Validate Arch
|
|
#
|
|
if (ArchItem == '' or ArchItem == None):
|
|
ArchItem = 'COMMON'
|
|
__SupArchList.append(ArchItem)
|
|
|
|
if UiInf != None:
|
|
if len(UiInf) > 0:
|
|
#
|
|
# Check UI
|
|
#
|
|
for UiItem in UiInf:
|
|
IsValidFileFlag = False
|
|
InfBianryUiItemObj = None
|
|
UiContent = UiItem[0]
|
|
UiComment = UiItem[1]
|
|
UiCurrentLine = UiItem[2]
|
|
GlobalData.gINF_CURRENT_LINE = deepcopy(UiItem[2])
|
|
#
|
|
# Should not less than 2 elements
|
|
#
|
|
if len(UiContent) < 2:
|
|
Logger.Error("InfParser",
|
|
ToolError.FORMAT_INVALID,
|
|
ST.ERR_INF_PARSER_BINARY_ITEM_FORMAT_INVALID % (UiContent[0], 2),
|
|
File=UiCurrentLine.GetFileName(),
|
|
Line=UiCurrentLine.GetLineNo(),
|
|
ExtraData=UiCurrentLine.GetLineString())
|
|
return False
|
|
|
|
if len(UiContent) > 4:
|
|
Logger.Error("InfParser",
|
|
ToolError.FORMAT_INVALID,
|
|
ST.ERR_INF_PARSER_BINARY_ITEM_FORMAT_INVALID_MAX % (UiContent[0], 4),
|
|
File=UiCurrentLine.GetFileName(),
|
|
Line=UiCurrentLine.GetLineNo(),
|
|
ExtraData=UiCurrentLine.GetLineString())
|
|
return False
|
|
if len(UiContent) >= 2:
|
|
#
|
|
# Create an Ui Object.
|
|
#
|
|
InfBianryUiItemObj = InfBianryUiItem()
|
|
if UiContent[0] != 'UI':
|
|
Logger.Error("InfParser",
|
|
ToolError.FORMAT_INVALID,
|
|
ST.ERR_INF_PARSER_BINARY_VER_TYPE % ('UI'),
|
|
File=UiCurrentLine.GetFileName(),
|
|
Line=UiCurrentLine.GetLineNo(),
|
|
ExtraData=UiCurrentLine.GetLineString())
|
|
InfBianryUiItemObj.SetUiTypeName(UiContent[0])
|
|
InfBianryUiItemObj.SetType(UiContent[0])
|
|
#
|
|
# Verify File exist or not
|
|
#
|
|
FullFileName = os.path.normpath(os.path.realpath(os.path.join(GlobalData.gINF_MODULE_DIR,
|
|
UiContent[1])))
|
|
if not (ValidFile(FullFileName) or ValidFile(UiContent[1])):
|
|
Logger.Error("InfParser",
|
|
ToolError.FORMAT_INVALID,
|
|
ST.ERR_INF_PARSER_BINARY_ITEM_FILE_NOT_EXIST % (UiContent[1]),
|
|
File=UiCurrentLine.GetFileName(),
|
|
Line=UiCurrentLine.GetLineNo(),
|
|
ExtraData=UiCurrentLine.GetLineString())
|
|
#
|
|
# Validate file exist/format.
|
|
#
|
|
if IsValidPath(UiContent[1], GlobalData.gINF_MODULE_DIR):
|
|
IsValidFileFlag = True
|
|
else:
|
|
Logger.Error("InfParser",
|
|
ToolError.FORMAT_INVALID,
|
|
ST.ERR_INF_PARSER_FILE_NOT_EXIST_OR_NAME_INVALID % (UiContent[1]),
|
|
File=UiCurrentLine.GetFileName(),
|
|
Line=UiCurrentLine.GetLineNo(),
|
|
ExtraData=UiCurrentLine.GetLineString())
|
|
return False
|
|
if IsValidFileFlag:
|
|
UiContent[0] = ConvPathFromAbsToRel(UiContent[0], GlobalData.gINF_MODULE_DIR)
|
|
InfBianryUiItemObj.SetFileName(UiContent[1])
|
|
if len(UiContent) >= 3:
|
|
#
|
|
# Add Target information
|
|
#
|
|
InfBianryUiItemObj.SetTarget(UiContent[2])
|
|
if len(UiContent) == 4:
|
|
if UiContent[3].strip() == '':
|
|
Logger.Error("InfParser",
|
|
ToolError.FORMAT_INVALID,
|
|
ST.ERR_INF_PARSER_FEATURE_FLAG_EXP_MISSING,
|
|
File=UiCurrentLine.GetFileName(),
|
|
Line=UiCurrentLine.GetLineNo(),
|
|
ExtraData=UiCurrentLine.GetLineString())
|
|
#
|
|
# Validate Feature Flag Express
|
|
#
|
|
FeatureFlagRtv = IsValidFeatureFlagExp(UiContent[3].strip())
|
|
if not FeatureFlagRtv[0]:
|
|
Logger.Error("InfParser",
|
|
ToolError.FORMAT_INVALID,
|
|
ST.ERR_INF_PARSER_FEATURE_FLAG_EXP_SYNTAX_INVLID % (FeatureFlagRtv[1]),
|
|
File=UiCurrentLine.GetFileName(),
|
|
Line=UiCurrentLine.GetLineNo(),
|
|
ExtraData=UiCurrentLine.GetLineString())
|
|
InfBianryUiItemObj.SetFeatureFlagExp(UiContent[3])
|
|
|
|
InfBianryUiItemObj.SetSupArchList(__SupArchList)
|
|
|
|
#
|
|
# Determine binary file name duplicate. Follow below rule:
|
|
#
|
|
# A binary filename must not be duplicated within
|
|
# a [Binaries] section. A binary filename may appear in
|
|
# multiple architectural [Binaries] sections. A binary
|
|
# filename listed in an architectural [Binaries] section
|
|
# must not be listed in the common architectural
|
|
# [Binaries] section.
|
|
#
|
|
# NOTE: This check will not report error now.
|
|
#
|
|
# for Item in self.Binaries:
|
|
# if Item.GetFileName() == InfBianryUiItemObj.GetFileName():
|
|
# ItemSupArchList = Item.GetSupArchList()
|
|
# for ItemArch in ItemSupArchList:
|
|
# for UiItemObjArch in __SupArchList:
|
|
# if ItemArch == UiItemObjArch:
|
|
# #
|
|
# # ST.ERR_INF_PARSER_ITEM_DUPLICATE
|
|
# #
|
|
# pass
|
|
# if ItemArch.upper() == 'COMMON' or UiItemObjArch.upper() == 'COMMON':
|
|
# #
|
|
# # ERR_INF_PARSER_ITEM_DUPLICATE_COMMON
|
|
# #
|
|
# pass
|
|
|
|
if InfBianryUiItemObj != None:
|
|
if self.Binaries.has_key((InfBianryUiItemObj)):
|
|
BinariesList = self.Binaries[InfBianryUiItemObj]
|
|
BinariesList.append((InfBianryUiItemObj, UiComment))
|
|
self.Binaries[InfBianryUiItemObj] = BinariesList
|
|
else:
|
|
BinariesList = []
|
|
BinariesList.append((InfBianryUiItemObj, UiComment))
|
|
self.Binaries[InfBianryUiItemObj] = BinariesList
|
|
if Ver != None and len(Ver) > 0:
|
|
self.CheckVer(Ver, __SupArchList)
|
|
if CommonBinary and len(CommonBinary) > 0:
|
|
self.ParseCommonBinary(CommonBinary, __SupArchList)
|
|
|
|
return True
|
|
|
|
def GetBinary(self):
|
|
return self.Binaries
|