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, Intel Corporation. All rights reserved.<BR>
   5 #
   6 # This program and the accompanying materials are licensed and made available
   7 # under the terms and conditions of the BSD License which accompanies this
   8 # distribution. The full text of the license may be found at
   9 # http://opensource.org/licenses/bsd-license.php
  10 #
  11 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13 #
  14
  15 '''
  16 PcdXml
  17 '''
  18
  19 ##
  20 # Import Modules
  21 #
  22
  23 from Library.Xml.XmlRoutines import XmlElement
  24 from Library.Xml.XmlRoutines import XmlAttribute
  25 from Library.Xml.XmlRoutines import XmlNode
  26 from Library.Xml.XmlRoutines import CreateXmlElement
  27 from Library.Xml.XmlRoutines import XmlList
  28 from Library.String import GetStringOfList
  29 from Library.String import ConvertNEToNOTEQ
  30 from Library.String import ConvertNOTEQToNE
  31 from Library import GlobalData
  32 from Object.POM.CommonObject import PcdObject
  33 from Object.POM.CommonObject import PcdErrorObject
  34 from Xml.CommonXml import HelpTextXml
  35 from Xml.CommonXml import CommonDefinesXml
  36 from Xml.XmlParserMisc import GetHelpTextList
  37
  38 ##
  39 # PcdErrorXml
  40 #
  41 class PcdErrorXml(object):
  42     def __init__(self):
  43         self.ValidValueList = ''
  44         self.ValidValueListLang = ''
  45         self.ValidValueRange = ''
  46         self.Expression = ''
  47         self.ErrorNumber = ''
  48         self.ErrorMessage = []
  49
  50     def FromXml(self, Item, Key):
  51         self.ValidValueList = XmlElement(Item, '%s/ValidValueList' % Key)
  52         self.ValidValueListLang = \
  53         XmlAttribute(XmlNode(Item, '%s/ValidValueList' % Key), 'Lang')
  54         self.ValidValueRange = XmlElement(Item, '%s/ValidValueRange' % Key)
  55         self.Expression = XmlElement(Item, '%s/Expression' % Key)
  56         self.ErrorNumber = XmlElement(Item, '%s/ErrorNumber' % Key)
  57         for ErrMsg in XmlList(Item, '%s/ErrorMessage' % Key):
  58             ErrorMessageString = XmlElement(ErrMsg, 'ErrorMessage')
  59             ErrorMessageLang = \
  60             XmlAttribute(XmlNode(ErrMsg, 'ErrorMessage'), 'Lang')
  61             self.ErrorMessage.append((ErrorMessageLang, ErrorMessageString))
  62
  63         Error = PcdErrorObject()
  64         Error.SetValidValue(self.ValidValueList)
  65         Error.SetValidValueLang(self.ValidValueListLang)
  66         Error.SetValidValueRange(self.ValidValueRange)
  67         Error.SetExpression(self.Expression)
  68         Error.SetErrorNumber(self.ErrorNumber)
  69         Error.SetErrorMessageList(self.ErrorMessage)
  70
  71         return Error
  72
  73     def ToXml(self, PcdError, Key):
  74         if self.Expression:
  75             pass
  76         AttributeList = []
  77         NodeList = []
  78         if PcdError.GetValidValue():
  79             Element1 = \
  80             CreateXmlElement('ValidValueList', PcdError.GetValidValue(), [], \
  81                              [['Lang', PcdError.GetValidValueLang()]])
  82             NodeList.append(Element1)
  83         if PcdError.GetValidValueRange():
  84             Element1 = \
  85             CreateXmlElement('ValidValueRange', \
  86                              PcdError.GetValidValueRange(), [], [])
  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 __str__(self):
 101         return "ValidValueList = %s ValidValueListLang = %s ValidValueRange \
 102         = %s Expression = %s ErrorNumber = %s %s" % \
 103         (self.ValidValueList, self.ValidValueListLang, self.ValidValueRange, \
 104          self.Expression, self.ErrorNumber, self.ErrorMessage)
 105
 106 ##
 107 # PcdEntryXml
 108 #
 109 class PcdEntryXml(object):
 110     def __init__(self):
 111         self.PcdItemType = ''
 112         self.PcdUsage = ''
 113         self.TokenSpaceGuidCName = ''
 114         self.TokenSpaceGuidValue = ''
 115         self.Token = ''
 116         self.CName = ''
 117         self.PcdCName = ''
 118         self.DatumType = ''
 119         self.ValidUsage = ''
 120         self.DefaultValue = ''
 121         self.MaxDatumSize = ''
 122         self.Value = ''
 123         self.Offset = ''
 124         self.CommonDefines = CommonDefinesXml()
 125         self.HelpText = []
 126         self.PcdError = []
 127
 128     ##
 129     # AsBuilt will use FromXml
 130     #
 131     def FromXml(self, Item, Key):
 132         self.PcdItemType = \
 133         XmlAttribute(XmlNode(Item, '%s' % Key), 'PcdItemType')
 134         self.PcdUsage = XmlAttribute(XmlNode(Item, '%s' % Key), 'PcdUsage')
 135         self.TokenSpaceGuidCName = \
 136         XmlElement(Item, '%s/TokenSpaceGuidCname' % Key)
 137         self.TokenSpaceGuidValue = \
 138         XmlElement(Item, '%s/TokenSpaceGuidValue' % Key)
 139         self.Token = XmlElement(Item, '%s/Token' % Key)
 140         self.CName = XmlElement(Item, '%s/CName' % Key)
 141         self.PcdCName = XmlElement(Item, '%s/PcdCName' % Key)
 142         self.DatumType = XmlElement(Item, '%s/DatumType' % Key)
 143         self.ValidUsage = XmlElement(Item, '%s/ValidUsage' % Key)
 144         if not GlobalData.gIS_BINARY_INF:
 145             self.DefaultValue = XmlElement(Item, '%s/DefaultValue' % Key)
 146         else:
 147             self.DefaultValue = XmlElement(Item, '%s/Value' % Key)
 148         self.MaxDatumSize = XmlElement(Item, '%s/MaxDatumSize' % Key)
 149         self.Value = XmlElement(Item, '%s/Value' % Key)
 150         self.Offset = XmlElement(Item, '%s/Offset' % Key)
 151         self.CommonDefines.FromXml(XmlNode(Item, '%s' % Key), Key)
 152         for HelpTextItem in XmlList(Item, '%s/HelpText' % Key):
 153             HelpTextObj = HelpTextXml()
 154             HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)
 155             self.HelpText.append(HelpTextObj)
 156         for PcdErrorItem in XmlList(Item, '%s/PcdError' % Key):
 157             PcdErrorObjXml = PcdErrorXml()
 158             PcdErrorObj = PcdErrorObjXml.FromXml(PcdErrorItem, 'PcdError')
 159             self.PcdError.append(PcdErrorObj)
 160
 161         self.DefaultValue = ConvertNOTEQToNE(self.DefaultValue)
 162
 163         PcdEntry = PcdObject()
 164         PcdEntry.SetSupArchList(self.CommonDefines.SupArchList)
 165         PcdEntry.SetTokenSpaceGuidCName(self.TokenSpaceGuidCName)
 166         PcdEntry.SetTokenSpaceGuidValue(self.TokenSpaceGuidValue)
 167         PcdEntry.SetToken(self.Token)
 168         PcdEntry.SetOffset(self.Offset)
 169         PcdEntry.SetCName(self.CName)
 170         PcdEntry.SetPcdCName(self.PcdCName)
 171         PcdEntry.SetDatumType(self.DatumType)
 172         PcdEntry.SetValidUsage(self.ValidUsage)
 173         PcdEntry.SetDefaultValue(self.DefaultValue)
 174         PcdEntry.SetMaxDatumSize(self.MaxDatumSize)
 175         PcdEntry.SetFeatureFlag(ConvertNOTEQToNE(self.CommonDefines.FeatureFlag))
 176         PcdEntry.SetItemType(self.PcdItemType)
 177
 178         PcdEntry.SetHelpTextList(GetHelpTextList(self.HelpText))
 179         PcdEntry.SetPcdErrorsList(self.PcdError)
 180
 181         return PcdEntry
 182     ##
 183     # Package will use FromXml2
 184     #
 185     def FromXml2(self, Item, Key):
 186         self.TokenSpaceGuidCName = \
 187         XmlElement(Item, '%s/TokenSpaceGuidCname' % Key)
 188         self.Token = XmlElement(Item, '%s/Token' % Key)
 189         self.CName = XmlElement(Item, '%s/CName' % Key)
 190         self.DatumType = XmlElement(Item, '%s/DatumType' % Key)
 191         self.ValidUsage = XmlElement(Item, '%s/ValidUsage' % Key)
 192         self.DefaultValue = XmlElement(Item, '%s/DefaultValue' % Key)
 193         self.MaxDatumSize = XmlElement(Item, '%s/MaxDatumSize' % Key)
 194         self.CommonDefines.FromXml(XmlNode(Item, '%s' % Key), Key)
 195         for HelpTextItem in XmlList(Item, '%s/HelpText' % Key):
 196             HelpTextObj = HelpTextXml()
 197             HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)
 198             self.HelpText.append(HelpTextObj)
 199         for PcdErrorItem in XmlList(Item, '%s/PcdError' % Key):
 200             PcdErrorObjXml = PcdErrorXml()
 201             PcdErrorObj = PcdErrorObjXml.FromXml(PcdErrorItem, 'PcdError')
 202             self.PcdError.append(PcdErrorObj)
 203
 204         self.DefaultValue = ConvertNOTEQToNE(self.DefaultValue)
 205
 206         PcdEntry = PcdObject()
 207         PcdEntry.SetSupArchList(self.CommonDefines.SupArchList)
 208         PcdEntry.SetSupModuleList(self.CommonDefines.SupModList)
 209         PcdEntry.SetTokenSpaceGuidCName(self.TokenSpaceGuidCName)
 210         PcdEntry.SetToken(self.Token)
 211         PcdEntry.SetCName(self.CName)
 212         PcdEntry.SetDatumType(self.DatumType)
 213         PcdEntry.SetValidUsage(self.ValidUsage)
 214         PcdEntry.SetDefaultValue(self.DefaultValue)
 215         PcdEntry.SetMaxDatumSize(self.MaxDatumSize)
 216         PcdEntry.SetFeatureFlag(ConvertNOTEQToNE(self.CommonDefines.FeatureFlag))
 217
 218         PcdEntry.SetHelpTextList(GetHelpTextList(self.HelpText))
 219         PcdEntry.SetPcdErrorsList(self.PcdError)
 220
 221         return PcdEntry
 222
 223     ##
 224     # Module will use FromXml3
 225     #
 226     def FromXml3(self, Item, Key):
 227         self.PcdItemType = \
 228         XmlAttribute(XmlNode(Item, '%s' % Key), 'PcdItemType')
 229         self.PcdUsage = XmlAttribute(XmlNode(Item, '%s' % Key), 'PcdUsage')
 230         self.TokenSpaceGuidCName = \
 231         XmlElement(Item, '%s/TokenSpaceGuidCName' % Key)
 232         self.CName = XmlElement(Item, '%s/CName' % Key)
 233         self.DefaultValue = XmlElement(Item, '%s/DefaultValue' % Key)
 234         self.CommonDefines.FromXml(XmlNode(Item, '%s' % Key), Key)
 235         for HelpTextItem in XmlList(Item, '%s/HelpText' % Key):
 236             HelpTextObj = HelpTextXml()
 237             HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)
 238             self.HelpText.append(HelpTextObj)
 239         for PcdErrorItem in XmlList(Item, '%s/PcdError' % Key):
 240             PcdErrorObj = PcdErrorXml()
 241             PcdErrorObj.FromXml(PcdErrorItem, 'PcdError')
 242             self.PcdError.append(PcdErrorObj)
 243
 244         self.DefaultValue = ConvertNOTEQToNE(self.DefaultValue)
 245
 246         PcdEntry = PcdObject()
 247         PcdEntry.SetSupArchList(self.CommonDefines.SupArchList)
 248         PcdEntry.SetTokenSpaceGuidCName(self.TokenSpaceGuidCName)
 249         PcdEntry.SetCName(self.CName)
 250         PcdEntry.SetValidUsage(self.PcdUsage)
 251         PcdEntry.SetDefaultValue(self.DefaultValue)
 252         PcdEntry.SetFeatureFlag(ConvertNOTEQToNE(self.CommonDefines.FeatureFlag))
 253         PcdEntry.SetItemType(self.PcdItemType)
 254
 255         PcdEntry.SetHelpTextList(GetHelpTextList(self.HelpText))
 256         PcdEntry.SetPcdErrorsList(self.PcdError)
 257
 258         return PcdEntry
 259
 260     def ToXml(self, PcdEntry, Key):
 261         if self.PcdCName:
 262             pass
 263
 264         DefaultValue = ConvertNEToNOTEQ(PcdEntry.GetDefaultValue())
 265
 266         AttributeList = \
 267         [['SupArchList', GetStringOfList(PcdEntry.GetSupArchList())], \
 268          ['PcdUsage', PcdEntry.GetValidUsage()], \
 269          ['PcdItemType', PcdEntry.GetItemType()], \
 270          ['FeatureFlag', PcdEntry.GetFeatureFlag()],
 271         ]
 272         NodeList = [['TokenSpaceGuidCname', PcdEntry.GetTokenSpaceGuidCName()],
 273                     ['TokenSpaceGuidValue', PcdEntry.GetTokenSpaceGuidValue()],
 274                     ['Token', PcdEntry.GetToken()],
 275                     ['CName', PcdEntry.GetCName()],
 276                     ['DatumType', PcdEntry.GetDatumType()],
 277                     ['ValidUsage', GetStringOfList(PcdEntry.GetValidUsage())],
 278                     ['DefaultValue', DefaultValue],
 279                     ['MaxDatumSize', PcdEntry.GetMaxDatumSize()],
 280                     ['Offset', PcdEntry.GetOffset()],
 281                    ]
 282
 283         for Item in PcdEntry.GetHelpTextList():
 284             Tmp = HelpTextXml()
 285             NodeList.append(Tmp.ToXml(Item))
 286         for Item in PcdEntry.GetPcdErrorsList():
 287             Tmp = PcdErrorXml()
 288             NodeList.append(Tmp.ToXml(Item, 'PcdError'))
 289
 290         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
 291
 292         return Root
 293     ##
 294     # Package will use ToXml2
 295     #
 296     def ToXml2(self, PcdEntry, Key):
 297         if self.PcdCName:
 298             pass
 299
 300         DefaultValue = ConvertNEToNOTEQ(PcdEntry.GetDefaultValue())
 301
 302         AttributeList = \
 303         [['SupArchList', GetStringOfList(PcdEntry.GetSupArchList())], \
 304          ['SupModList', GetStringOfList(PcdEntry.GetSupModuleList())]
 305         ]
 306         NodeList = [['TokenSpaceGuidCname', PcdEntry.GetTokenSpaceGuidCName()],
 307                     ['Token', PcdEntry.GetToken()],
 308                     ['CName', PcdEntry.GetCName()],
 309                     ['DatumType', PcdEntry.GetDatumType()],
 310                     ['ValidUsage', GetStringOfList(PcdEntry.GetValidUsage())],
 311                     ['DefaultValue', DefaultValue],
 312                     ['MaxDatumSize', PcdEntry.GetMaxDatumSize()],
 313                    ]
 314         for Item in PcdEntry.GetHelpTextList():
 315             Tmp = HelpTextXml()
 316             NodeList.append(Tmp.ToXml(Item))
 317
 318         for Item in PcdEntry.GetPcdErrorsList():
 319             Tmp = PcdErrorXml()
 320             NodeList.append(Tmp.ToXml(Item, 'PcdError'))
 321
 322         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
 323
 324         return Root
 325     ##
 326     # Module will use ToXml3
 327     #
 328     def ToXml3(self, PcdEntry, Key):
 329         if self.PcdCName:
 330             pass
 331
 332         DefaultValue = ConvertNEToNOTEQ(PcdEntry.GetDefaultValue())
 333
 334         AttributeList = \
 335         [['SupArchList', GetStringOfList(PcdEntry.GetSupArchList())], \
 336          ['PcdUsage', PcdEntry.GetValidUsage()], \
 337          ['PcdItemType', PcdEntry.GetItemType()], \
 338          ['FeatureFlag', ConvertNEToNOTEQ(PcdEntry.GetFeatureFlag())],
 339         ]
 340         NodeList = [['CName', PcdEntry.GetCName()],
 341                     ['TokenSpaceGuidCName', PcdEntry.GetTokenSpaceGuidCName()],
 342                     ['DefaultValue', DefaultValue],
 343                    ]
 344
 345         for Item in PcdEntry.GetHelpTextList():
 346             Tmp = HelpTextXml()
 347             NodeList.append(Tmp.ToXml(Item))
 348         for Item in PcdEntry.GetPcdErrorsList():
 349             Tmp = PcdErrorXml()
 350             NodeList.append(Tmp.ToXml(Item, 'PcdError'))
 351
 352         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
 353
 354         return Root
 355
 356     ##
 357     # AsBuild Module will use ToXml4
 358     #
 359     def ToXml4(self, PcdEntry, Key):
 360         if self.PcdCName:
 361             pass
 362
 363         DefaultValue = ConvertNEToNOTEQ(PcdEntry.GetDefaultValue())
 364
 365         AttributeList = []
 366
 367         NodeList = [
 368                     ['TokenSpaceGuidValue', PcdEntry.GetTokenSpaceGuidValue()],
 369                     ['PcdCName', PcdEntry.GetCName()],
 370                     ['Token', PcdEntry.GetToken()],
 371                     ['DatumType', PcdEntry.GetDatumType()],
 372                     ['MaxDatumSize', PcdEntry.GetMaxDatumSize()],
 373                     ['Value', DefaultValue],
 374                     ['Offset', PcdEntry.GetOffset()]
 375                    ]
 376
 377         for Item in PcdEntry.GetHelpTextList():
 378             Tmp = HelpTextXml()
 379             NodeList.append(Tmp.ToXml(Item))
 380         for Item in PcdEntry.GetPcdErrorsList():
 381             Tmp = PcdErrorXml()
 382             NodeList.append(Tmp.ToXml(Item, 'PcdError'))
 383
 384         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
 385
 386         return Root
 387
 388
 389     def __str__(self):
 390         Str = \
 391         ('PcdItemType = %s PcdUsage = %s TokenSpaceGuidCName = %s \
 392         TokenSpaceGuidValue = %s Token = %s CName = %s PcdCName = %s \
 393         DatumType = %s ValidUsage = %s DefaultValue = %s MaxDatumSize = %s \
 394         Value = %s Offset = %s %s') % \
 395         (self.PcdItemType, self.PcdUsage, self.TokenSpaceGuidCName, \
 396          self.TokenSpaceGuidValue, self.Token, self.CName, self.PcdCName, \
 397          self.DatumType, self.ValidUsage, self.DefaultValue, \
 398          self.MaxDatumSize, self.Value, self.Offset, self.CommonDefines)
 399         for Item in self.HelpText:
 400             Str = Str + "\n\t" + str(Item)
 401         for Item in self.PcdError:
 402             Str = Str + "\n\tPcdError:" + str(Item)
 403         return Str