mirror of
https://github.com/acidanthera/audk.git
synced 2025-04-08 17:05:09 +02:00
6820004b3e
In Python 3.12 invalid escape sequences in strings moved from DeprecationWarning to SyntaxWarning (ref https://docs.python.org/3/whatsnew/changelog.html#python-3-12-0-final and search for gh-98401). In a future Python version this will become SyntaxError. Multiple instances of these SyntaxWarnings are currently printed when running the BaseTools tests using Python 3.12 (though without actually failing the affected tests). This commit updates all lines which were causing this type of warning. Typical examples which needed fixing are: - "BaseTools\Source\Python" representing a path: "\S" and "\P" are invalid escape sequences, therefore left unchanged, therefore the test works (with a warning in Python 3.12). r"BaseTools\Source\Python" represents the same string, but with escapes turned off completely thus no warning. - Where '\t\s' is used as a regex pattern, then chr(9) + '\\s' is sent to the regex parser (with a warning in Python 3.12) since '\s' is not a valid Python escape sequence. This works correctly, though arguably for the wrong reasons. r'\t\s' sends the same as '\\t\\s', as originally intended and with no warning. (Note that ' and " are not fundamentally different in Python.) Signed-off-by: Mike Beaton <mjsbeaton@gmail.com>
556 lines
22 KiB
Python
556 lines
22 KiB
Python
## @file
|
|
# This file is used to parse a PCD file of .PKG file
|
|
#
|
|
# Copyright (c) 2011 - 2018, Intel Corporation. All rights reserved.<BR>
|
|
#
|
|
# SPDX-License-Identifier: BSD-2-Clause-Patent
|
|
#
|
|
|
|
'''
|
|
PcdXml
|
|
'''
|
|
|
|
##
|
|
# Import Modules
|
|
#
|
|
|
|
from Library.Xml.XmlRoutines import XmlElement
|
|
from Library.Xml.XmlRoutines import XmlAttribute
|
|
from Library.Xml.XmlRoutines import XmlNode
|
|
from Library.Xml.XmlRoutines import CreateXmlElement
|
|
from Library.Xml.XmlRoutines import XmlList
|
|
from Library.StringUtils import GetStringOfList
|
|
from Library.StringUtils import ConvertNEToNOTEQ
|
|
from Library.StringUtils import ConvertNOTEQToNE
|
|
from Library import GlobalData
|
|
from Object.POM.CommonObject import PcdObject
|
|
from Object.POM.CommonObject import PcdErrorObject
|
|
from Xml.CommonXml import HelpTextXml
|
|
from Xml.CommonXml import PromptXml
|
|
from Xml.CommonXml import CommonDefinesXml
|
|
from Xml.XmlParserMisc import GetHelpTextList
|
|
from Xml.XmlParserMisc import GetPromptList
|
|
import re
|
|
|
|
##
|
|
# PcdErrorXml
|
|
#
|
|
class PcdErrorXml(object):
|
|
def __init__(self):
|
|
self.ValidValueList = ''
|
|
self.ValidValueListLang = ''
|
|
self.ValidValueRange = ''
|
|
self.Expression = ''
|
|
self.ErrorNumber = ''
|
|
self.ErrorMessage = []
|
|
|
|
def FromXml(self, Item, Key):
|
|
self.ValidValueList = XmlElement(Item, '%s/ValidValueList' % Key)
|
|
self.ValidValueListLang = \
|
|
XmlAttribute(XmlNode(Item, '%s/ValidValueList' % Key), 'Lang')
|
|
self.ValidValueRange = self.TransferValidEpxr2ValidRange(XmlElement(Item, '%s/ValidValueRange' % Key))
|
|
self.Expression = XmlElement(Item, '%s/Expression' % Key)
|
|
self.ErrorNumber = XmlElement(Item, '%s/ErrorNumber' % Key)
|
|
for ErrMsg in XmlList(Item, '%s/ErrorMessage' % Key):
|
|
ErrorMessageString = XmlElement(ErrMsg, 'ErrorMessage')
|
|
ErrorMessageLang = \
|
|
XmlAttribute(XmlNode(ErrMsg, 'ErrorMessage'), 'Lang')
|
|
self.ErrorMessage.append((ErrorMessageLang, ErrorMessageString))
|
|
|
|
Error = PcdErrorObject()
|
|
Error.SetValidValue(self.ValidValueList)
|
|
Error.SetValidValueLang(self.ValidValueListLang)
|
|
Error.SetValidValueRange(self.ValidValueRange)
|
|
Error.SetExpression(self.Expression)
|
|
Error.SetErrorNumber(self.ErrorNumber)
|
|
Error.SetErrorMessageList(self.ErrorMessage)
|
|
|
|
return Error
|
|
|
|
def ToXml(self, PcdError, Key):
|
|
if self.Expression:
|
|
pass
|
|
AttributeList = []
|
|
NodeList = []
|
|
if PcdError.GetValidValue():
|
|
Element1 = \
|
|
CreateXmlElement('ValidValueList', PcdError.GetValidValue(), [], \
|
|
[['Lang', PcdError.GetValidValueLang()]])
|
|
NodeList.append(Element1)
|
|
if PcdError.GetValidValueRange():
|
|
TansferedRangeStr = self.TransferValidRange2Expr(PcdError.GetTokenSpaceGuidCName(),
|
|
PcdError.GetCName(),
|
|
PcdError.GetValidValueRange())
|
|
Element1 = \
|
|
CreateXmlElement('ValidValueRange', \
|
|
TansferedRangeStr, [], [])
|
|
NodeList.append(Element1)
|
|
if PcdError.GetExpression():
|
|
NodeList.append(['Expression', PcdError.GetExpression()])
|
|
if PcdError.GetErrorNumber():
|
|
NodeList.append(['ErrorNumber', PcdError.GetErrorNumber()])
|
|
for Item in PcdError.GetErrorMessageList():
|
|
Element = \
|
|
CreateXmlElement('ErrorMessage', Item[1], [], [['Lang', Item[0]]])
|
|
NodeList.append(Element)
|
|
Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
|
|
|
|
return Root
|
|
|
|
def TransferValidRange2Expr(self, TokenSpaceGuidCName, CName, ValidRange):
|
|
if self.Expression:
|
|
pass
|
|
INT_RANGE_PATTERN1 = r'[\t\s]*[0-9]+[\t\s]*-[\t\s]*[0-9]+'
|
|
INT_RANGE_PATTERN2 = r'[\t\s]*(LT|GT|LE|GE|XOR|EQ)[\t\s]+\d+[\t\s]*'
|
|
HEX_RANGE_PATTERN1 = \
|
|
r'[\t\s]*0[xX][a-fA-F0-9]+[\t\s]*-[\t\s]*0[xX][a-fA-F0-9]+'
|
|
HEX_RANGE_PATTERN2 = r'[\t\s]*(LT|GT|LE|GE|XOR|EQ)[\t\s]+0[xX][a-fA-F0-9]+[\t\s]*'
|
|
IntMatch1 = re.compile(INT_RANGE_PATTERN1)
|
|
IntMatch2 = re.compile(INT_RANGE_PATTERN2)
|
|
HexMatch1 = re.compile(HEX_RANGE_PATTERN1)
|
|
HexMatch2 = re.compile(HEX_RANGE_PATTERN2)
|
|
PcdName = '.'.join([TokenSpaceGuidCName, CName])
|
|
HexMatchedList = []
|
|
IntMatchedList = []
|
|
#
|
|
# Convert HEX2 format range
|
|
#
|
|
if HexMatch2:
|
|
for MatchObj in HexMatch2.finditer(ValidRange):
|
|
MatchStr = MatchObj.group()
|
|
TransferedRangeStr = ' '.join(['', PcdName, MatchStr.strip()])
|
|
ValidRange = ValidRange.replace(MatchStr, TransferedRangeStr)
|
|
#
|
|
# Convert INT2 format range
|
|
#
|
|
if IntMatch2:
|
|
for MatchObj in IntMatch2.finditer(ValidRange):
|
|
MatchStr = MatchObj.group()
|
|
TransferedRangeStr = ' '.join(['', PcdName, MatchStr.strip()])
|
|
ValidRange = ValidRange.replace(MatchStr, TransferedRangeStr)
|
|
#
|
|
# Convert HEX1 format range
|
|
#
|
|
if HexMatch1:
|
|
HexMatchedList += HexMatch1.findall(ValidRange)
|
|
|
|
for MatchStr in HexMatchedList:
|
|
RangeItemList = MatchStr.strip().split('-')
|
|
TransferedRangeStr = '(%s GE %s) AND (%s LE %s)' % \
|
|
(PcdName, RangeItemList[0].strip(), PcdName, RangeItemList[1].strip())
|
|
ValidRange = ValidRange.replace(MatchStr, TransferedRangeStr)
|
|
#
|
|
# Convert INT1 format range
|
|
#
|
|
if IntMatch1:
|
|
IntMatchedList += IntMatch1.findall(ValidRange)
|
|
|
|
for MatchStr in IntMatchedList:
|
|
RangeItemList = MatchStr.strip().split('-')
|
|
TransferedRangeStr = '(%s GE %s) AND (%s LE %s)' % \
|
|
(PcdName, RangeItemList[0].strip(), PcdName, RangeItemList[1].strip())
|
|
ValidRange = ValidRange.replace(MatchStr, TransferedRangeStr)
|
|
|
|
return ValidRange
|
|
|
|
def TransferValidEpxr2ValidRange(self, ValidRangeExpr):
|
|
if self.Expression:
|
|
pass
|
|
|
|
PCD_PATTERN = \
|
|
r'[\t\s]*[_a-zA-Z][a-zA-Z0-9_]*[\t\s]*\.[\t\s]*[_a-zA-Z][a-zA-Z0-9_]*[\t\s]*'
|
|
IntPattern1 = \
|
|
r'[\t\s]*\([\t\s]*'+PCD_PATTERN+r'[\t\s]+GE[\t\s]+\d+[\t\s]*\)[\t\s]+AND[\t\s]+\([\t\s]*'+\
|
|
PCD_PATTERN+r'[\t\s]+LE[\t\s]+\d+[\t\s]*\)'
|
|
IntPattern1 = IntPattern1.replace(' ', '')
|
|
IntPattern2 = r'[\t\s]*'+PCD_PATTERN+r'[\t\s]+(LT|GT|LE|GE|XOR|EQ)[\t\s]+\d+[\t\s]*'
|
|
|
|
HexPattern1 = \
|
|
r'[\t\s]*\([\t\s]*'+PCD_PATTERN+r'[\t\s]+GE[\t\s]+0[xX][0-9a-fA-F]+[\t\s]*\)[\t\s]+AND[\t\s]+\([\t\s]*'+\
|
|
PCD_PATTERN+r'[\t\s]+LE[\t\s]+0[xX][0-9a-fA-F]+[\t\s]*\)'
|
|
HexPattern1 = HexPattern1.replace(' ', '')
|
|
HexPattern2 = r'[\t\s]*'+PCD_PATTERN+r'[\t\s]+(LT|GT|LE|GE|XOR|EQ)[\t\s]+0[xX][0-9a-zA-Z]+[\t\s]*'
|
|
|
|
#
|
|
# Do the Hex1 conversion
|
|
#
|
|
HexMatchedList = re.compile(HexPattern1).findall(ValidRangeExpr)
|
|
HexRangeDict = {}
|
|
for HexMatchedItem in HexMatchedList:
|
|
#
|
|
# To match items on both sides of '-'
|
|
#
|
|
RangeItemList = re.compile(r'[\t\s]*0[xX][0-9a-fA-F]+[\t\s]*').findall(HexMatchedItem)
|
|
if RangeItemList and len(RangeItemList) == 2:
|
|
HexRangeDict[HexMatchedItem] = RangeItemList
|
|
|
|
for Key in HexRangeDict.keys():
|
|
MaxItem = MixItem = ''
|
|
if int(HexRangeDict[Key][0], 16) > int(HexRangeDict[Key][1], 16):
|
|
MaxItem = HexRangeDict[Key][0]
|
|
MixItem = HexRangeDict[Key][1]
|
|
else:
|
|
MaxItem = HexRangeDict[Key][1]
|
|
MixItem = HexRangeDict[Key][0]
|
|
|
|
Range = ' %s - %s' % (MixItem.strip(), MaxItem.strip())
|
|
ValidRangeExpr = ValidRangeExpr.replace(Key, Range)
|
|
#
|
|
# Do the INT1 conversion
|
|
#
|
|
IntRangeDict = {}
|
|
IntMatchList = re.compile(IntPattern1).findall(ValidRangeExpr)
|
|
for MatchedItem in IntMatchList:
|
|
#
|
|
# To match items on both sides of '-'
|
|
#
|
|
RangeItemList = re.compile(r'[\t\s]*\d+[\t\s]*').findall(MatchedItem)
|
|
if RangeItemList and len(RangeItemList) == 2:
|
|
IntRangeDict[MatchedItem] = RangeItemList
|
|
|
|
for Key in IntRangeDict.keys():
|
|
MaxItem = MixItem = ''
|
|
if int(IntRangeDict[Key][0]) > int(IntRangeDict[Key][1]):
|
|
MaxItem = IntRangeDict[Key][0]
|
|
MixItem = IntRangeDict[Key][1]
|
|
else:
|
|
MaxItem = IntRangeDict[Key][1]
|
|
MixItem = IntRangeDict[Key][0]
|
|
|
|
Range = ' %s - %s' % (MixItem.strip(), MaxItem.strip())
|
|
ValidRangeExpr = ValidRangeExpr.replace(Key, Range)
|
|
#
|
|
# Do the HEX2 conversion
|
|
#
|
|
for MatchObj in re.compile(HexPattern2).finditer(ValidRangeExpr):
|
|
MatchStr = MatchObj.group()
|
|
Range = re.compile(PCD_PATTERN).sub(' ', MatchStr)
|
|
ValidRangeExpr = ValidRangeExpr.replace(MatchStr, Range)
|
|
#
|
|
# Do the INT2 conversion
|
|
#
|
|
for MatchObj in re.compile(IntPattern2).finditer(ValidRangeExpr):
|
|
MatchStr = MatchObj.group()
|
|
Range = re.compile(PCD_PATTERN).sub(' ', MatchStr)
|
|
ValidRangeExpr = ValidRangeExpr.replace(MatchStr, Range)
|
|
|
|
return ValidRangeExpr
|
|
|
|
|
|
|
|
def __str__(self):
|
|
return "ValidValueList = %s ValidValueListLang = %s ValidValueRange \
|
|
= %s Expression = %s ErrorNumber = %s %s" % \
|
|
(self.ValidValueList, self.ValidValueListLang, self.ValidValueRange, \
|
|
self.Expression, self.ErrorNumber, self.ErrorMessage)
|
|
|
|
##
|
|
# PcdEntryXml
|
|
#
|
|
class PcdEntryXml(object):
|
|
def __init__(self):
|
|
self.PcdItemType = ''
|
|
self.PcdUsage = ''
|
|
self.TokenSpaceGuidCName = ''
|
|
self.TokenSpaceGuidValue = ''
|
|
self.Token = ''
|
|
self.CName = ''
|
|
self.PcdCName = ''
|
|
self.DatumType = ''
|
|
self.ValidUsage = ''
|
|
self.DefaultValue = ''
|
|
self.MaxDatumSize = ''
|
|
self.Value = ''
|
|
self.Offset = ''
|
|
self.CommonDefines = CommonDefinesXml()
|
|
self.Prompt = []
|
|
self.HelpText = []
|
|
self.PcdError = []
|
|
|
|
##
|
|
# AsBuilt will use FromXml
|
|
#
|
|
def FromXml(self, Item, Key):
|
|
self.PcdItemType = \
|
|
XmlAttribute(XmlNode(Item, '%s' % Key), 'PcdItemType')
|
|
self.PcdUsage = XmlAttribute(XmlNode(Item, '%s' % Key), 'PcdUsage')
|
|
self.TokenSpaceGuidCName = \
|
|
XmlElement(Item, '%s/TokenSpaceGuidCname' % Key)
|
|
self.TokenSpaceGuidValue = \
|
|
XmlElement(Item, '%s/TokenSpaceGuidValue' % Key)
|
|
self.Token = XmlElement(Item, '%s/Token' % Key)
|
|
self.CName = XmlElement(Item, '%s/CName' % Key)
|
|
self.PcdCName = XmlElement(Item, '%s/PcdCName' % Key)
|
|
self.DatumType = XmlElement(Item, '%s/DatumType' % Key)
|
|
self.ValidUsage = XmlElement(Item, '%s/ValidUsage' % Key)
|
|
if not GlobalData.gIS_BINARY_INF:
|
|
self.DefaultValue = XmlElement(Item, '%s/DefaultValue' % Key)
|
|
else:
|
|
self.DefaultValue = XmlElement(Item, '%s/Value' % Key)
|
|
self.MaxDatumSize = XmlElement(Item, '%s/MaxDatumSize' % Key)
|
|
self.Value = XmlElement(Item, '%s/Value' % Key)
|
|
self.Offset = XmlElement(Item, '%s/Offset' % Key)
|
|
self.CommonDefines.FromXml(XmlNode(Item, '%s' % Key), Key)
|
|
|
|
for HelpTextItem in XmlList(Item, '%s/HelpText' % Key):
|
|
HelpTextObj = HelpTextXml()
|
|
HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)
|
|
self.HelpText.append(HelpTextObj)
|
|
for PcdErrorItem in XmlList(Item, '%s/PcdError' % Key):
|
|
PcdErrorObjXml = PcdErrorXml()
|
|
PcdErrorObj = PcdErrorObjXml.FromXml(PcdErrorItem, 'PcdError')
|
|
self.PcdError.append(PcdErrorObj)
|
|
|
|
self.DefaultValue = ConvertNOTEQToNE(self.DefaultValue)
|
|
|
|
PcdEntry = PcdObject()
|
|
PcdEntry.SetSupArchList(self.CommonDefines.SupArchList)
|
|
PcdEntry.SetTokenSpaceGuidCName(self.TokenSpaceGuidCName)
|
|
PcdEntry.SetTokenSpaceGuidValue(self.TokenSpaceGuidValue)
|
|
PcdEntry.SetToken(self.Token)
|
|
PcdEntry.SetOffset(self.Offset)
|
|
PcdEntry.SetCName(self.CName)
|
|
PcdEntry.SetPcdCName(self.PcdCName)
|
|
PcdEntry.SetDatumType(self.DatumType)
|
|
PcdEntry.SetValidUsage(self.ValidUsage)
|
|
PcdEntry.SetDefaultValue(self.DefaultValue)
|
|
PcdEntry.SetMaxDatumSize(self.MaxDatumSize)
|
|
PcdEntry.SetFeatureFlag(ConvertNOTEQToNE(self.CommonDefines.FeatureFlag))
|
|
PcdEntry.SetItemType(self.PcdItemType)
|
|
|
|
PcdEntry.SetHelpTextList(GetHelpTextList(self.HelpText))
|
|
PcdEntry.SetPcdErrorsList(self.PcdError)
|
|
|
|
return PcdEntry
|
|
##
|
|
# Package will use FromXml2
|
|
#
|
|
def FromXml2(self, Item, Key):
|
|
self.TokenSpaceGuidCName = \
|
|
XmlElement(Item, '%s/TokenSpaceGuidCname' % Key)
|
|
self.Token = XmlElement(Item, '%s/Token' % Key)
|
|
self.CName = XmlElement(Item, '%s/CName' % Key)
|
|
self.DatumType = XmlElement(Item, '%s/DatumType' % Key)
|
|
self.ValidUsage = XmlElement(Item, '%s/ValidUsage' % Key)
|
|
self.DefaultValue = XmlElement(Item, '%s/DefaultValue' % Key)
|
|
self.MaxDatumSize = XmlElement(Item, '%s/MaxDatumSize' % Key)
|
|
self.CommonDefines.FromXml(XmlNode(Item, '%s' % Key), Key)
|
|
for PromptItem in XmlList(Item, '%s/Prompt' % Key):
|
|
PromptObj = PromptXml()
|
|
PromptObj.FromXml(PromptItem, '%s/Prompt' % Key)
|
|
self.Prompt.append(PromptObj)
|
|
for HelpTextItem in XmlList(Item, '%s/HelpText' % Key):
|
|
HelpTextObj = HelpTextXml()
|
|
HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)
|
|
self.HelpText.append(HelpTextObj)
|
|
for PcdErrorItem in XmlList(Item, '%s/PcdError' % Key):
|
|
PcdErrorObjXml = PcdErrorXml()
|
|
PcdErrorObj = PcdErrorObjXml.FromXml(PcdErrorItem, 'PcdError')
|
|
self.PcdError.append(PcdErrorObj)
|
|
|
|
self.DefaultValue = ConvertNOTEQToNE(self.DefaultValue)
|
|
|
|
PcdEntry = PcdObject()
|
|
PcdEntry.SetSupArchList(self.CommonDefines.SupArchList)
|
|
PcdEntry.SetSupModuleList(self.CommonDefines.SupModList)
|
|
PcdEntry.SetTokenSpaceGuidCName(self.TokenSpaceGuidCName)
|
|
PcdEntry.SetToken(self.Token)
|
|
PcdEntry.SetCName(self.CName)
|
|
PcdEntry.SetDatumType(self.DatumType)
|
|
PcdEntry.SetValidUsage(self.ValidUsage)
|
|
PcdEntry.SetDefaultValue(self.DefaultValue)
|
|
PcdEntry.SetMaxDatumSize(self.MaxDatumSize)
|
|
PcdEntry.SetFeatureFlag(ConvertNOTEQToNE(self.CommonDefines.FeatureFlag))
|
|
|
|
PcdEntry.SetPromptList(GetPromptList(self.Prompt))
|
|
PcdEntry.SetHelpTextList(GetHelpTextList(self.HelpText))
|
|
PcdEntry.SetPcdErrorsList(self.PcdError)
|
|
|
|
return PcdEntry
|
|
|
|
##
|
|
# Module will use FromXml3
|
|
#
|
|
def FromXml3(self, Item, Key):
|
|
self.PcdItemType = \
|
|
XmlAttribute(XmlNode(Item, '%s' % Key), 'PcdItemType')
|
|
self.PcdUsage = XmlAttribute(XmlNode(Item, '%s' % Key), 'PcdUsage')
|
|
self.TokenSpaceGuidCName = \
|
|
XmlElement(Item, '%s/TokenSpaceGuidCName' % Key)
|
|
self.CName = XmlElement(Item, '%s/CName' % Key)
|
|
self.DefaultValue = XmlElement(Item, '%s/DefaultValue' % Key)
|
|
self.CommonDefines.FromXml(XmlNode(Item, '%s' % Key), Key)
|
|
for HelpTextItem in XmlList(Item, '%s/HelpText' % Key):
|
|
HelpTextObj = HelpTextXml()
|
|
HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)
|
|
self.HelpText.append(HelpTextObj)
|
|
for PcdErrorItem in XmlList(Item, '%s/PcdError' % Key):
|
|
PcdErrorObj = PcdErrorXml()
|
|
PcdErrorObj.FromXml(PcdErrorItem, 'PcdError')
|
|
self.PcdError.append(PcdErrorObj)
|
|
|
|
self.DefaultValue = ConvertNOTEQToNE(self.DefaultValue)
|
|
|
|
PcdEntry = PcdObject()
|
|
PcdEntry.SetSupArchList(self.CommonDefines.SupArchList)
|
|
PcdEntry.SetTokenSpaceGuidCName(self.TokenSpaceGuidCName)
|
|
PcdEntry.SetCName(self.CName)
|
|
PcdEntry.SetValidUsage(self.PcdUsage)
|
|
PcdEntry.SetDefaultValue(self.DefaultValue)
|
|
PcdEntry.SetFeatureFlag(ConvertNOTEQToNE(self.CommonDefines.FeatureFlag))
|
|
PcdEntry.SetItemType(self.PcdItemType)
|
|
|
|
PcdEntry.SetHelpTextList(GetHelpTextList(self.HelpText))
|
|
PcdEntry.SetPcdErrorsList(self.PcdError)
|
|
|
|
return PcdEntry
|
|
|
|
def ToXml(self, PcdEntry, Key):
|
|
if self.PcdCName:
|
|
pass
|
|
|
|
DefaultValue = ConvertNEToNOTEQ(PcdEntry.GetDefaultValue())
|
|
|
|
AttributeList = \
|
|
[['SupArchList', GetStringOfList(PcdEntry.GetSupArchList())], \
|
|
['PcdUsage', PcdEntry.GetValidUsage()], \
|
|
['PcdItemType', PcdEntry.GetItemType()], \
|
|
['FeatureFlag', PcdEntry.GetFeatureFlag()],
|
|
]
|
|
NodeList = [['TokenSpaceGuidCname', PcdEntry.GetTokenSpaceGuidCName()],
|
|
['TokenSpaceGuidValue', PcdEntry.GetTokenSpaceGuidValue()],
|
|
['Token', PcdEntry.GetToken()],
|
|
['CName', PcdEntry.GetCName()],
|
|
['DatumType', PcdEntry.GetDatumType()],
|
|
['ValidUsage', GetStringOfList(PcdEntry.GetValidUsage())],
|
|
['DefaultValue', DefaultValue],
|
|
['MaxDatumSize', PcdEntry.GetMaxDatumSize()],
|
|
['Offset', PcdEntry.GetOffset()],
|
|
]
|
|
|
|
for Item in PcdEntry.GetHelpTextList():
|
|
Tmp = HelpTextXml()
|
|
NodeList.append(Tmp.ToXml(Item))
|
|
for Item in PcdEntry.GetPcdErrorsList():
|
|
Tmp = PcdErrorXml()
|
|
NodeList.append(Tmp.ToXml(Item, 'PcdError'))
|
|
|
|
Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
|
|
|
|
return Root
|
|
##
|
|
# Package will use ToXml2
|
|
#
|
|
def ToXml2(self, PcdEntry, Key):
|
|
if self.PcdCName:
|
|
pass
|
|
|
|
DefaultValue = ConvertNEToNOTEQ(PcdEntry.GetDefaultValue())
|
|
|
|
AttributeList = \
|
|
[['SupArchList', GetStringOfList(PcdEntry.GetSupArchList())], \
|
|
['SupModList', GetStringOfList(PcdEntry.GetSupModuleList())]
|
|
]
|
|
NodeList = [['TokenSpaceGuidCname', PcdEntry.GetTokenSpaceGuidCName()],
|
|
['Token', PcdEntry.GetToken()],
|
|
['CName', PcdEntry.GetCName()],
|
|
['DatumType', PcdEntry.GetDatumType()],
|
|
['ValidUsage', GetStringOfList(PcdEntry.GetValidUsage())],
|
|
['DefaultValue', DefaultValue],
|
|
['MaxDatumSize', PcdEntry.GetMaxDatumSize()],
|
|
]
|
|
for Item in PcdEntry.GetPromptList():
|
|
Tmp = PromptXml()
|
|
NodeList.append(Tmp.ToXml(Item))
|
|
|
|
for Item in PcdEntry.GetHelpTextList():
|
|
Tmp = HelpTextXml()
|
|
NodeList.append(Tmp.ToXml(Item))
|
|
|
|
for Item in PcdEntry.GetPcdErrorsList():
|
|
Tmp = PcdErrorXml()
|
|
NodeList.append(Tmp.ToXml(Item, 'PcdError'))
|
|
|
|
Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
|
|
|
|
return Root
|
|
##
|
|
# Module will use ToXml3
|
|
#
|
|
def ToXml3(self, PcdEntry, Key):
|
|
if self.PcdCName:
|
|
pass
|
|
|
|
DefaultValue = ConvertNEToNOTEQ(PcdEntry.GetDefaultValue())
|
|
|
|
AttributeList = \
|
|
[['SupArchList', GetStringOfList(PcdEntry.GetSupArchList())], \
|
|
['PcdUsage', PcdEntry.GetValidUsage()], \
|
|
['PcdItemType', PcdEntry.GetItemType()], \
|
|
['FeatureFlag', ConvertNEToNOTEQ(PcdEntry.GetFeatureFlag())],
|
|
]
|
|
NodeList = [['CName', PcdEntry.GetCName()],
|
|
['TokenSpaceGuidCName', PcdEntry.GetTokenSpaceGuidCName()],
|
|
['DefaultValue', DefaultValue],
|
|
]
|
|
|
|
for Item in PcdEntry.GetHelpTextList():
|
|
Tmp = HelpTextXml()
|
|
NodeList.append(Tmp.ToXml(Item))
|
|
for Item in PcdEntry.GetPcdErrorsList():
|
|
Tmp = PcdErrorXml()
|
|
NodeList.append(Tmp.ToXml(Item, 'PcdError'))
|
|
|
|
Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
|
|
|
|
return Root
|
|
|
|
##
|
|
# AsBuild Module will use ToXml4
|
|
#
|
|
def ToXml4(self, PcdEntry, Key):
|
|
if self.PcdCName:
|
|
pass
|
|
|
|
DefaultValue = ConvertNEToNOTEQ(PcdEntry.GetDefaultValue())
|
|
|
|
AttributeList = []
|
|
|
|
NodeList = [
|
|
['TokenSpaceGuidValue', PcdEntry.GetTokenSpaceGuidValue()],
|
|
['PcdCName', PcdEntry.GetCName()],
|
|
['Token', PcdEntry.GetToken()],
|
|
['DatumType', PcdEntry.GetDatumType()],
|
|
['MaxDatumSize', PcdEntry.GetMaxDatumSize()],
|
|
['Value', DefaultValue],
|
|
['Offset', PcdEntry.GetOffset()]
|
|
]
|
|
|
|
for Item in PcdEntry.GetHelpTextList():
|
|
Tmp = HelpTextXml()
|
|
NodeList.append(Tmp.ToXml(Item))
|
|
for Item in PcdEntry.GetPcdErrorsList():
|
|
Tmp = PcdErrorXml()
|
|
NodeList.append(Tmp.ToXml(Item, 'PcdError'))
|
|
|
|
Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
|
|
|
|
return Root
|
|
|
|
|
|
def __str__(self):
|
|
Str = \
|
|
('PcdItemType = %s PcdUsage = %s TokenSpaceGuidCName = %s \
|
|
TokenSpaceGuidValue = %s Token = %s CName = %s PcdCName = %s \
|
|
DatumType = %s ValidUsage = %s DefaultValue = %s MaxDatumSize = %s \
|
|
Value = %s Offset = %s %s') % \
|
|
(self.PcdItemType, self.PcdUsage, self.TokenSpaceGuidCName, \
|
|
self.TokenSpaceGuidValue, self.Token, self.CName, self.PcdCName, \
|
|
self.DatumType, self.ValidUsage, self.DefaultValue, \
|
|
self.MaxDatumSize, self.Value, self.Offset, self.CommonDefines)
|
|
for Item in self.HelpText:
|
|
Str = Str + "\n\t" + str(Item)
|
|
for Item in self.PcdError:
|
|
Str = Str + "\n\tPcdError:" + str(Item)
|
|
return Str
|