BaseTools/Source/Python/UPT/Xml/PcdXml.py

   1 ## @file
   2 # This file is used to parse a PCD file of .PKG file
   3 #
   4 # Copyright (c) 2011 - 2018, Intel Corporation. All rights reserved.<BR>
   5 #
   6 # SPDX-License-Identifier: BSD-2-Clause-Patent
   7 #
   8
   9 '''
  10 PcdXml
  11 '''
  12
  13 ##
  14 # Import Modules
  15 #
  16
  17 from Library.Xml.XmlRoutines import XmlElement
  18 from Library.Xml.XmlRoutines import XmlAttribute
  19 from Library.Xml.XmlRoutines import XmlNode
  20 from Library.Xml.XmlRoutines import CreateXmlElement
  21 from Library.Xml.XmlRoutines import XmlList
  22 from Library.StringUtils import GetStringOfList
  23 from Library.StringUtils import ConvertNEToNOTEQ
  24 from Library.StringUtils import ConvertNOTEQToNE
  25 from Library import GlobalData
  26 from Object.POM.CommonObject import PcdObject
  27 from Object.POM.CommonObject import PcdErrorObject
  28 from Xml.CommonXml import HelpTextXml
  29 from Xml.CommonXml import PromptXml
  30 from Xml.CommonXml import CommonDefinesXml
  31 from Xml.XmlParserMisc import GetHelpTextList
  32 from Xml.XmlParserMisc import GetPromptList
  33 import re
  34
  35 ##
  36 # PcdErrorXml
  37 #
  38 class PcdErrorXml(object):
  39     def __init__(self):
  40         self.ValidValueList = ''
  41         self.ValidValueListLang = ''
  42         self.ValidValueRange = ''
  43         self.Expression = ''
  44         self.ErrorNumber = ''
  45         self.ErrorMessage = []
  46
  47     def FromXml(self, Item, Key):
  48         self.ValidValueList = XmlElement(Item, '%s/ValidValueList' % Key)
  49         self.ValidValueListLang = \
  50         XmlAttribute(XmlNode(Item, '%s/ValidValueList' % Key), 'Lang')
  51         self.ValidValueRange = self.TransferValidEpxr2ValidRange(XmlElement(Item, '%s/ValidValueRange' % Key))
  52         self.Expression = XmlElement(Item, '%s/Expression' % Key)
  53         self.ErrorNumber = XmlElement(Item, '%s/ErrorNumber' % Key)
  54         for ErrMsg in XmlList(Item, '%s/ErrorMessage' % Key):
  55             ErrorMessageString = XmlElement(ErrMsg, 'ErrorMessage')
  56             ErrorMessageLang = \
  57             XmlAttribute(XmlNode(ErrMsg, 'ErrorMessage'), 'Lang')
  58             self.ErrorMessage.append((ErrorMessageLang, ErrorMessageString))
  59
  60         Error = PcdErrorObject()
  61         Error.SetValidValue(self.ValidValueList)
  62         Error.SetValidValueLang(self.ValidValueListLang)
  63         Error.SetValidValueRange(self.ValidValueRange)
  64         Error.SetExpression(self.Expression)
  65         Error.SetErrorNumber(self.ErrorNumber)
  66         Error.SetErrorMessageList(self.ErrorMessage)
  67
  68         return Error
  69
  70     def ToXml(self, PcdError, Key):
  71         if self.Expression:
  72             pass
  73         AttributeList = []
  74         NodeList = []
  75         if PcdError.GetValidValue():
  76             Element1 = \
  77             CreateXmlElement('ValidValueList', PcdError.GetValidValue(), [], \
  78                              [['Lang', PcdError.GetValidValueLang()]])
  79             NodeList.append(Element1)
  80         if PcdError.GetValidValueRange():
  81             TansferedRangeStr = self.TransferValidRange2Expr(PcdError.GetTokenSpaceGuidCName(),
  82                                                              PcdError.GetCName(),
  83                                                              PcdError.GetValidValueRange())
  84             Element1 = \
  85             CreateXmlElement('ValidValueRange', \
  86                              TansferedRangeStr, [], [])
  87             NodeList.append(Element1)
  88         if PcdError.GetExpression():
  89             NodeList.append(['Expression', PcdError.GetExpression()])
  90         if PcdError.GetErrorNumber():
  91             NodeList.append(['ErrorNumber', PcdError.GetErrorNumber()])
  92         for Item in PcdError.GetErrorMessageList():
  93             Element = \
  94             CreateXmlElement('ErrorMessage', Item[1], [], [['Lang', Item[0]]])
  95             NodeList.append(Element)
  96         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
  97
  98         return Root
  99
 100     def TransferValidRange2Expr(self, TokenSpaceGuidCName, CName, ValidRange):
 101         if self.Expression:
 102             pass
 103         INT_RANGE_PATTERN1 = '[\t\s]*[0-9]+[\t\s]*-[\t\s]*[0-9]+'
 104         INT_RANGE_PATTERN2 = '[\t\s]*(LT|GT|LE|GE|XOR|EQ)[\t\s]+\d+[\t\s]*'
 105         HEX_RANGE_PATTERN1 = \
 106             '[\t\s]*0[xX][a-fA-F0-9]+[\t\s]*-[\t\s]*0[xX][a-fA-F0-9]+'
 107         HEX_RANGE_PATTERN2 = '[\t\s]*(LT|GT|LE|GE|XOR|EQ)[\t\s]+0[xX][a-fA-F0-9]+[\t\s]*'
 108         IntMatch1 = re.compile(INT_RANGE_PATTERN1)
 109         IntMatch2 = re.compile(INT_RANGE_PATTERN2)
 110         HexMatch1 = re.compile(HEX_RANGE_PATTERN1)
 111         HexMatch2 = re.compile(HEX_RANGE_PATTERN2)
 112         PcdName = '.'.join([TokenSpaceGuidCName, CName])
 113         HexMatchedList = []
 114         IntMatchedList = []
 115         #
 116         # Convert HEX2 format range
 117         #
 118         if HexMatch2:
 119             for MatchObj in HexMatch2.finditer(ValidRange):
 120                 MatchStr = MatchObj.group()
 121                 TransferedRangeStr = ' '.join(['', PcdName, MatchStr.strip()])
 122                 ValidRange = ValidRange.replace(MatchStr, TransferedRangeStr)
 123         #
 124         # Convert INT2 format range
 125         #
 126         if IntMatch2:
 127             for MatchObj in IntMatch2.finditer(ValidRange):
 128                 MatchStr = MatchObj.group()
 129                 TransferedRangeStr = ' '.join(['', PcdName, MatchStr.strip()])
 130                 ValidRange = ValidRange.replace(MatchStr, TransferedRangeStr)
 131         #
 132         # Convert HEX1 format range
 133         #
 134         if HexMatch1:
 135             HexMatchedList += HexMatch1.findall(ValidRange)
 136
 137         for MatchStr in HexMatchedList:
 138             RangeItemList = MatchStr.strip().split('-')
 139             TransferedRangeStr = '(%s GE %s) AND (%s LE %s)' % \
 140                 (PcdName, RangeItemList[0].strip(), PcdName, RangeItemList[1].strip())
 141             ValidRange = ValidRange.replace(MatchStr, TransferedRangeStr)
 142         #
 143         # Convert INT1 format range
 144         #
 145         if IntMatch1:
 146             IntMatchedList += IntMatch1.findall(ValidRange)
 147
 148         for MatchStr in IntMatchedList:
 149             RangeItemList = MatchStr.strip().split('-')
 150             TransferedRangeStr = '(%s GE %s) AND (%s LE %s)' % \
 151                 (PcdName, RangeItemList[0].strip(), PcdName, RangeItemList[1].strip())
 152             ValidRange = ValidRange.replace(MatchStr, TransferedRangeStr)
 153
 154         return ValidRange
 155
 156     def TransferValidEpxr2ValidRange(self, ValidRangeExpr):
 157         if self.Expression:
 158             pass
 159
 160         PCD_PATTERN = \
 161         '[\t\s]*[_a-zA-Z][a-zA-Z0-9_]*[\t\s]*\.[\t\s]*[_a-zA-Z][a-zA-Z0-9_]*[\t\s]*'
 162         IntPattern1 = \
 163         '[\t\s]*\([\t\s]*'+PCD_PATTERN+'[\t\s]+GE[\t\s]+\d+[\t\s]*\)[\t\s]+AND[\t\s]+\([\t\s]*'+\
 164         PCD_PATTERN+'[\t\s]+LE[\t\s]+\d+[\t\s]*\)'
 165         IntPattern1 = IntPattern1.replace(' ', '')
 166         IntPattern2 = '[\t\s]*'+PCD_PATTERN+'[\t\s]+(LT|GT|LE|GE|XOR|EQ)[\t\s]+\d+[\t\s]*'
 167
 168         HexPattern1 = \
 169         '[\t\s]*\([\t\s]*'+PCD_PATTERN+'[\t\s]+GE[\t\s]+0[xX][0-9a-fA-F]+[\t\s]*\)[\t\s]+AND[\t\s]+\([\t\s]*'+\
 170         PCD_PATTERN+'[\t\s]+LE[\t\s]+0[xX][0-9a-fA-F]+[\t\s]*\)'
 171         HexPattern1 = HexPattern1.replace(' ', '')
 172         HexPattern2 = '[\t\s]*'+PCD_PATTERN+'[\t\s]+(LT|GT|LE|GE|XOR|EQ)[\t\s]+0[xX][0-9a-zA-Z]+[\t\s]*'
 173
 174         #
 175         # Do the Hex1 conversion
 176         #
 177         HexMatchedList = re.compile(HexPattern1).findall(ValidRangeExpr)
 178         HexRangeDict = {}
 179         for HexMatchedItem in HexMatchedList:
 180             #
 181             # To match items on both sides of '-'
 182             #
 183             RangeItemList = re.compile('[\t\s]*0[xX][0-9a-fA-F]+[\t\s]*').findall(HexMatchedItem)
 184             if RangeItemList and len(RangeItemList) == 2:
 185                 HexRangeDict[HexMatchedItem] = RangeItemList
 186
 187         for Key in HexRangeDict.keys():
 188             MaxItem = MixItem = ''
 189             if int(HexRangeDict[Key][0], 16) > int(HexRangeDict[Key][1], 16):
 190                 MaxItem = HexRangeDict[Key][0]
 191                 MixItem = HexRangeDict[Key][1]
 192             else:
 193                 MaxItem = HexRangeDict[Key][1]
 194                 MixItem = HexRangeDict[Key][0]
 195
 196             Range = ' %s - %s' % (MixItem.strip(), MaxItem.strip())
 197             ValidRangeExpr = ValidRangeExpr.replace(Key, Range)
 198         #
 199         # Do the INT1 conversion
 200         #
 201         IntRangeDict = {}
 202         IntMatchList = re.compile(IntPattern1).findall(ValidRangeExpr)
 203         for MatchedItem in IntMatchList:
 204             #
 205             # To match items on both sides of '-'
 206             #
 207             RangeItemList = re.compile('[\t\s]*\d+[\t\s]*').findall(MatchedItem)
 208             if RangeItemList and len(RangeItemList) == 2:
 209                 IntRangeDict[MatchedItem] = RangeItemList
 210
 211         for Key in IntRangeDict.keys():
 212             MaxItem = MixItem = ''
 213             if int(IntRangeDict[Key][0]) > int(IntRangeDict[Key][1]):
 214                 MaxItem = IntRangeDict[Key][0]
 215                 MixItem = IntRangeDict[Key][1]
 216             else:
 217                 MaxItem = IntRangeDict[Key][1]
 218                 MixItem = IntRangeDict[Key][0]
 219
 220             Range = ' %s - %s' % (MixItem.strip(), MaxItem.strip())
 221             ValidRangeExpr = ValidRangeExpr.replace(Key, Range)
 222         #
 223         # Do the HEX2 conversion
 224         #
 225         for MatchObj in re.compile(HexPattern2).finditer(ValidRangeExpr):
 226             MatchStr = MatchObj.group()
 227             Range = re.compile(PCD_PATTERN).sub(' ', MatchStr)
 228             ValidRangeExpr = ValidRangeExpr.replace(MatchStr, Range)
 229         #
 230         # Do the INT2 conversion
 231         #
 232         for MatchObj in re.compile(IntPattern2).finditer(ValidRangeExpr):
 233             MatchStr = MatchObj.group()
 234             Range = re.compile(PCD_PATTERN).sub(' ', MatchStr)
 235             ValidRangeExpr = ValidRangeExpr.replace(MatchStr, Range)
 236
 237         return ValidRangeExpr
 238
 239
 240
 241     def __str__(self):
 242         return "ValidValueList = %s ValidValueListLang = %s ValidValueRange \
 243         = %s Expression = %s ErrorNumber = %s %s" % \
 244         (self.ValidValueList, self.ValidValueListLang, self.ValidValueRange, \
 245          self.Expression, self.ErrorNumber, self.ErrorMessage)
 246
 247 ##
 248 # PcdEntryXml
 249 #
 250 class PcdEntryXml(object):
 251     def __init__(self):
 252         self.PcdItemType = ''
 253         self.PcdUsage = ''
 254         self.TokenSpaceGuidCName = ''
 255         self.TokenSpaceGuidValue = ''
 256         self.Token = ''
 257         self.CName = ''
 258         self.PcdCName = ''
 259         self.DatumType = ''
 260         self.ValidUsage = ''
 261         self.DefaultValue = ''
 262         self.MaxDatumSize = ''
 263         self.Value = ''
 264         self.Offset = ''
 265         self.CommonDefines = CommonDefinesXml()
 266         self.Prompt = []
 267         self.HelpText = []
 268         self.PcdError = []
 269
 270     ##
 271     # AsBuilt will use FromXml
 272     #
 273     def FromXml(self, Item, Key):
 274         self.PcdItemType = \
 275         XmlAttribute(XmlNode(Item, '%s' % Key), 'PcdItemType')
 276         self.PcdUsage = XmlAttribute(XmlNode(Item, '%s' % Key), 'PcdUsage')
 277         self.TokenSpaceGuidCName = \
 278         XmlElement(Item, '%s/TokenSpaceGuidCname' % Key)
 279         self.TokenSpaceGuidValue = \
 280         XmlElement(Item, '%s/TokenSpaceGuidValue' % Key)
 281         self.Token = XmlElement(Item, '%s/Token' % Key)
 282         self.CName = XmlElement(Item, '%s/CName' % Key)
 283         self.PcdCName = XmlElement(Item, '%s/PcdCName' % Key)
 284         self.DatumType = XmlElement(Item, '%s/DatumType' % Key)
 285         self.ValidUsage = XmlElement(Item, '%s/ValidUsage' % Key)
 286         if not GlobalData.gIS_BINARY_INF:
 287             self.DefaultValue = XmlElement(Item, '%s/DefaultValue' % Key)
 288         else:
 289             self.DefaultValue = XmlElement(Item, '%s/Value' % Key)
 290         self.MaxDatumSize = XmlElement(Item, '%s/MaxDatumSize' % Key)
 291         self.Value = XmlElement(Item, '%s/Value' % Key)
 292         self.Offset = XmlElement(Item, '%s/Offset' % Key)
 293         self.CommonDefines.FromXml(XmlNode(Item, '%s' % Key), Key)
 294
 295         for HelpTextItem in XmlList(Item, '%s/HelpText' % Key):
 296             HelpTextObj = HelpTextXml()
 297             HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)
 298             self.HelpText.append(HelpTextObj)
 299         for PcdErrorItem in XmlList(Item, '%s/PcdError' % Key):
 300             PcdErrorObjXml = PcdErrorXml()
 301             PcdErrorObj = PcdErrorObjXml.FromXml(PcdErrorItem, 'PcdError')
 302             self.PcdError.append(PcdErrorObj)
 303
 304         self.DefaultValue = ConvertNOTEQToNE(self.DefaultValue)
 305
 306         PcdEntry = PcdObject()
 307         PcdEntry.SetSupArchList(self.CommonDefines.SupArchList)
 308         PcdEntry.SetTokenSpaceGuidCName(self.TokenSpaceGuidCName)
 309         PcdEntry.SetTokenSpaceGuidValue(self.TokenSpaceGuidValue)
 310         PcdEntry.SetToken(self.Token)
 311         PcdEntry.SetOffset(self.Offset)
 312         PcdEntry.SetCName(self.CName)
 313         PcdEntry.SetPcdCName(self.PcdCName)
 314         PcdEntry.SetDatumType(self.DatumType)
 315         PcdEntry.SetValidUsage(self.ValidUsage)
 316         PcdEntry.SetDefaultValue(self.DefaultValue)
 317         PcdEntry.SetMaxDatumSize(self.MaxDatumSize)
 318         PcdEntry.SetFeatureFlag(ConvertNOTEQToNE(self.CommonDefines.FeatureFlag))
 319         PcdEntry.SetItemType(self.PcdItemType)
 320
 321         PcdEntry.SetHelpTextList(GetHelpTextList(self.HelpText))
 322         PcdEntry.SetPcdErrorsList(self.PcdError)
 323
 324         return PcdEntry
 325     ##
 326     # Package will use FromXml2
 327     #
 328     def FromXml2(self, Item, Key):
 329         self.TokenSpaceGuidCName = \
 330         XmlElement(Item, '%s/TokenSpaceGuidCname' % Key)
 331         self.Token = XmlElement(Item, '%s/Token' % Key)
 332         self.CName = XmlElement(Item, '%s/CName' % Key)
 333         self.DatumType = XmlElement(Item, '%s/DatumType' % Key)
 334         self.ValidUsage = XmlElement(Item, '%s/ValidUsage' % Key)
 335         self.DefaultValue = XmlElement(Item, '%s/DefaultValue' % Key)
 336         self.MaxDatumSize = XmlElement(Item, '%s/MaxDatumSize' % Key)
 337         self.CommonDefines.FromXml(XmlNode(Item, '%s' % Key), Key)
 338         for PromptItem in XmlList(Item, '%s/Prompt' % Key):
 339             PromptObj = PromptXml()
 340             PromptObj.FromXml(PromptItem, '%s/Prompt' % Key)
 341             self.Prompt.append(PromptObj)
 342         for HelpTextItem in XmlList(Item, '%s/HelpText' % Key):
 343             HelpTextObj = HelpTextXml()
 344             HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)
 345             self.HelpText.append(HelpTextObj)
 346         for PcdErrorItem in XmlList(Item, '%s/PcdError' % Key):
 347             PcdErrorObjXml = PcdErrorXml()
 348             PcdErrorObj = PcdErrorObjXml.FromXml(PcdErrorItem, 'PcdError')
 349             self.PcdError.append(PcdErrorObj)
 350
 351         self.DefaultValue = ConvertNOTEQToNE(self.DefaultValue)
 352
 353         PcdEntry = PcdObject()
 354         PcdEntry.SetSupArchList(self.CommonDefines.SupArchList)
 355         PcdEntry.SetSupModuleList(self.CommonDefines.SupModList)
 356         PcdEntry.SetTokenSpaceGuidCName(self.TokenSpaceGuidCName)
 357         PcdEntry.SetToken(self.Token)
 358         PcdEntry.SetCName(self.CName)
 359         PcdEntry.SetDatumType(self.DatumType)
 360         PcdEntry.SetValidUsage(self.ValidUsage)
 361         PcdEntry.SetDefaultValue(self.DefaultValue)
 362         PcdEntry.SetMaxDatumSize(self.MaxDatumSize)
 363         PcdEntry.SetFeatureFlag(ConvertNOTEQToNE(self.CommonDefines.FeatureFlag))
 364
 365         PcdEntry.SetPromptList(GetPromptList(self.Prompt))
 366         PcdEntry.SetHelpTextList(GetHelpTextList(self.HelpText))
 367         PcdEntry.SetPcdErrorsList(self.PcdError)
 368
 369         return PcdEntry
 370
 371     ##
 372     # Module will use FromXml3
 373     #
 374     def FromXml3(self, Item, Key):
 375         self.PcdItemType = \
 376         XmlAttribute(XmlNode(Item, '%s' % Key), 'PcdItemType')
 377         self.PcdUsage = XmlAttribute(XmlNode(Item, '%s' % Key), 'PcdUsage')
 378         self.TokenSpaceGuidCName = \
 379         XmlElement(Item, '%s/TokenSpaceGuidCName' % Key)
 380         self.CName = XmlElement(Item, '%s/CName' % Key)
 381         self.DefaultValue = XmlElement(Item, '%s/DefaultValue' % Key)
 382         self.CommonDefines.FromXml(XmlNode(Item, '%s' % Key), Key)
 383         for HelpTextItem in XmlList(Item, '%s/HelpText' % Key):
 384             HelpTextObj = HelpTextXml()
 385             HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)
 386             self.HelpText.append(HelpTextObj)
 387         for PcdErrorItem in XmlList(Item, '%s/PcdError' % Key):
 388             PcdErrorObj = PcdErrorXml()
 389             PcdErrorObj.FromXml(PcdErrorItem, 'PcdError')
 390             self.PcdError.append(PcdErrorObj)
 391
 392         self.DefaultValue = ConvertNOTEQToNE(self.DefaultValue)
 393
 394         PcdEntry = PcdObject()
 395         PcdEntry.SetSupArchList(self.CommonDefines.SupArchList)
 396         PcdEntry.SetTokenSpaceGuidCName(self.TokenSpaceGuidCName)
 397         PcdEntry.SetCName(self.CName)
 398         PcdEntry.SetValidUsage(self.PcdUsage)
 399         PcdEntry.SetDefaultValue(self.DefaultValue)
 400         PcdEntry.SetFeatureFlag(ConvertNOTEQToNE(self.CommonDefines.FeatureFlag))
 401         PcdEntry.SetItemType(self.PcdItemType)
 402
 403         PcdEntry.SetHelpTextList(GetHelpTextList(self.HelpText))
 404         PcdEntry.SetPcdErrorsList(self.PcdError)
 405
 406         return PcdEntry
 407
 408     def ToXml(self, PcdEntry, Key):
 409         if self.PcdCName:
 410             pass
 411
 412         DefaultValue = ConvertNEToNOTEQ(PcdEntry.GetDefaultValue())
 413
 414         AttributeList = \
 415         [['SupArchList', GetStringOfList(PcdEntry.GetSupArchList())], \
 416          ['PcdUsage', PcdEntry.GetValidUsage()], \
 417          ['PcdItemType', PcdEntry.GetItemType()], \
 418          ['FeatureFlag', PcdEntry.GetFeatureFlag()],
 419         ]
 420         NodeList = [['TokenSpaceGuidCname', PcdEntry.GetTokenSpaceGuidCName()],
 421                     ['TokenSpaceGuidValue', PcdEntry.GetTokenSpaceGuidValue()],
 422                     ['Token', PcdEntry.GetToken()],
 423                     ['CName', PcdEntry.GetCName()],
 424                     ['DatumType', PcdEntry.GetDatumType()],
 425                     ['ValidUsage', GetStringOfList(PcdEntry.GetValidUsage())],
 426                     ['DefaultValue', DefaultValue],
 427                     ['MaxDatumSize', PcdEntry.GetMaxDatumSize()],
 428                     ['Offset', PcdEntry.GetOffset()],
 429                    ]
 430
 431         for Item in PcdEntry.GetHelpTextList():
 432             Tmp = HelpTextXml()
 433             NodeList.append(Tmp.ToXml(Item))
 434         for Item in PcdEntry.GetPcdErrorsList():
 435             Tmp = PcdErrorXml()
 436             NodeList.append(Tmp.ToXml(Item, 'PcdError'))
 437
 438         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
 439
 440         return Root
 441     ##
 442     # Package will use ToXml2
 443     #
 444     def ToXml2(self, PcdEntry, Key):
 445         if self.PcdCName:
 446             pass
 447
 448         DefaultValue = ConvertNEToNOTEQ(PcdEntry.GetDefaultValue())
 449
 450         AttributeList = \
 451         [['SupArchList', GetStringOfList(PcdEntry.GetSupArchList())], \
 452          ['SupModList', GetStringOfList(PcdEntry.GetSupModuleList())]
 453         ]
 454         NodeList = [['TokenSpaceGuidCname', PcdEntry.GetTokenSpaceGuidCName()],
 455                     ['Token', PcdEntry.GetToken()],
 456                     ['CName', PcdEntry.GetCName()],
 457                     ['DatumType', PcdEntry.GetDatumType()],
 458                     ['ValidUsage', GetStringOfList(PcdEntry.GetValidUsage())],
 459                     ['DefaultValue', DefaultValue],
 460                     ['MaxDatumSize', PcdEntry.GetMaxDatumSize()],
 461                    ]
 462         for Item in PcdEntry.GetPromptList():
 463             Tmp = PromptXml()
 464             NodeList.append(Tmp.ToXml(Item))
 465
 466         for Item in PcdEntry.GetHelpTextList():
 467             Tmp = HelpTextXml()
 468             NodeList.append(Tmp.ToXml(Item))
 469
 470         for Item in PcdEntry.GetPcdErrorsList():
 471             Tmp = PcdErrorXml()
 472             NodeList.append(Tmp.ToXml(Item, 'PcdError'))
 473
 474         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
 475
 476         return Root
 477     ##
 478     # Module will use ToXml3
 479     #
 480     def ToXml3(self, PcdEntry, Key):
 481         if self.PcdCName:
 482             pass
 483
 484         DefaultValue = ConvertNEToNOTEQ(PcdEntry.GetDefaultValue())
 485
 486         AttributeList = \
 487         [['SupArchList', GetStringOfList(PcdEntry.GetSupArchList())], \
 488          ['PcdUsage', PcdEntry.GetValidUsage()], \
 489          ['PcdItemType', PcdEntry.GetItemType()], \
 490          ['FeatureFlag', ConvertNEToNOTEQ(PcdEntry.GetFeatureFlag())],
 491         ]
 492         NodeList = [['CName', PcdEntry.GetCName()],
 493                     ['TokenSpaceGuidCName', PcdEntry.GetTokenSpaceGuidCName()],
 494                     ['DefaultValue', DefaultValue],
 495                    ]
 496
 497         for Item in PcdEntry.GetHelpTextList():
 498             Tmp = HelpTextXml()
 499             NodeList.append(Tmp.ToXml(Item))
 500         for Item in PcdEntry.GetPcdErrorsList():
 501             Tmp = PcdErrorXml()
 502             NodeList.append(Tmp.ToXml(Item, 'PcdError'))
 503
 504         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
 505
 506         return Root
 507
 508     ##
 509     # AsBuild Module will use ToXml4
 510     #
 511     def ToXml4(self, PcdEntry, Key):
 512         if self.PcdCName:
 513             pass
 514
 515         DefaultValue = ConvertNEToNOTEQ(PcdEntry.GetDefaultValue())
 516
 517         AttributeList = []
 518
 519         NodeList = [
 520                     ['TokenSpaceGuidValue', PcdEntry.GetTokenSpaceGuidValue()],
 521                     ['PcdCName', PcdEntry.GetCName()],
 522                     ['Token', PcdEntry.GetToken()],
 523                     ['DatumType', PcdEntry.GetDatumType()],
 524                     ['MaxDatumSize', PcdEntry.GetMaxDatumSize()],
 525                     ['Value', DefaultValue],
 526                     ['Offset', PcdEntry.GetOffset()]
 527                    ]
 528
 529         for Item in PcdEntry.GetHelpTextList():
 530             Tmp = HelpTextXml()
 531             NodeList.append(Tmp.ToXml(Item))
 532         for Item in PcdEntry.GetPcdErrorsList():
 533             Tmp = PcdErrorXml()
 534             NodeList.append(Tmp.ToXml(Item, 'PcdError'))
 535
 536         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
 537
 538         return Root
 539
 540
 541     def __str__(self):
 542         Str = \
 543         ('PcdItemType = %s PcdUsage = %s TokenSpaceGuidCName = %s \
 544         TokenSpaceGuidValue = %s Token = %s CName = %s PcdCName = %s \
 545         DatumType = %s ValidUsage = %s DefaultValue = %s MaxDatumSize = %s \
 546         Value = %s Offset = %s %s') % \
 547         (self.PcdItemType, self.PcdUsage, self.TokenSpaceGuidCName, \
 548          self.TokenSpaceGuidValue, self.Token, self.CName, self.PcdCName, \
 549          self.DatumType, self.ValidUsage, self.DefaultValue, \
 550          self.MaxDatumSize, self.Value, self.Offset, self.CommonDefines)
 551         for Item in self.HelpText:
 552             Str = Str + "\n\t" + str(Item)
 553         for Item in self.PcdError:
 554             Str = Str + "\n\tPcdError:" + str(Item)
 555         return Str