BaseTools/Source/Python/Common/XmlParser.py

   1 ## @file
   2 # This file is used to parse a xml file of .PKG file
   3 #
   4 # Copyright (c) 2008, Intel Corporation. All rights reserved.<BR>
   5 # This program and the accompanying materials
   6 # are licensed and made available under the terms and conditions of the BSD License
   7 # which accompanies this distribution.  The full text of the license may be found at
   8 # http://opensource.org/licenses/bsd-license.php
   9 #
  10 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12 #
  13
  14 ##
  15 # Import Modules
  16 #
  17 from xml.dom import minidom
  18 from XmlRoutines import *
  19 from CommonDataClass.DistributionPackageClass import *
  20 from CommonDataClass.PackageClass import *
  21 from CommonDataClass.ModuleClass import *
  22 from Common.String import GetStringOfList
  23
  24 #
  25 # Get Help Text
  26 #
  27 def GetHelpTextList(HelpText):
  28     HelpTextList = []
  29     for HT in HelpText:
  30         HelpTextObj = HelpTextClass()
  31         HelpTextObj.Lang = HT.Lang
  32         HelpTextObj.String = HT.HelpText
  33         HelpTextList.append(HelpTextObj)
  34     return HelpTextList
  35
  36 # HeaderXml
  37 class HeaderXml(object):
  38     def __init__(self):
  39         self.Name = ''
  40         self.BaseName = ''
  41         self.GUID = ''
  42         self.Version = ''
  43         self.Copyright = ''
  44         self.License = ''
  45         self.Abstract = ''
  46         self.Description = ''
  47
  48     def FromXml(self, Item, Key):
  49         self.Name = XmlElement(Item, '%s/Name' % Key)
  50         self.BaseName = XmlAttribute(XmlNode(Item, '%s/Name' % Key), 'BaseName')
  51         self.GUID = XmlElement(Item, '%s/GUID' % Key)
  52         self.Version = XmlAttribute(XmlNode(Item, '%s/GUID' % Key), 'Version')
  53         self.Copyright = XmlElement(Item, '%s/Copyright' % Key)
  54         self.License = XmlElement(Item, '%s/License' % Key)
  55         self.Abstract = XmlElement(Item, '%s/Abstract' % Key)
  56         self.Description = XmlElement(Item, '%s/Description' % Key)
  57
  58         ModuleHeader = ModuleHeaderClass()
  59         ModuleHeader.Name = self.Name
  60         ModuleHeader.BaseName = self.BaseName
  61         ModuleHeader.Guid = self.GUID
  62         ModuleHeader.Version = self.Version
  63         ModuleHeader.Copyright = self.Copyright
  64         ModuleHeader.License = self.License
  65         ModuleHeader.Abstract = self.Abstract
  66         ModuleHeader.Description = self.Description
  67
  68         return ModuleHeader
  69
  70     def ToXml(self, Header, Key):
  71         Element1 = CreateXmlElement('Name', Header.Name, [], [['BaseName', Header.BaseName]])
  72         Element2 = CreateXmlElement('GUID', Header.Guid, [], [['Version', Header.Version]])
  73         AttributeList = []
  74         NodeList = [Element1,
  75                     Element2,
  76                     ['Abstract', Header.Abstract],
  77                     ['Copyright', Header.Copyright],
  78                     ['License', Header.License],
  79                     ['Description', Header.Description],
  80                     ]
  81         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
  82
  83         return Root
  84
  85     def __str__(self):
  86         return "Name = %s BaseName = %s GUID = %s Version = %s Copyright = %s License = %s Abstract = %s Description = %s" \
  87                % (self.Name, self.BaseName, self.GUID, self.Version, self.Copyright, self.License, self.Abstract, self.Description)
  88
  89 # DistributionPackageHeaderXml
  90 class DistributionPackageHeaderXml(object):
  91     def __init__(self):
  92         self.Header = HeaderXml()
  93         self.ReadOnly = False
  94         self.RePackage = True
  95         self.Vendor = ''
  96         self.Date = ''
  97         self.Signature = ''
  98         self.XmlSpecification = ''
  99
 100     def FromXml(self, Item, Key):
 101         self.ReadOnly = XmlAttribute(XmlNode(Item, '%s' % Key), 'ReadOnly')
 102         self.RePackage = XmlAttribute(XmlNode(Item, '%s' % Key), 'RePackage')
 103         self.Vendor = XmlElement(Item, '%s/Vendor' % Key)
 104         self.Date = XmlElement(Item, '%s/Date' % Key)
 105         self.Signature = XmlElement(Item, '%s/Signature' % Key)
 106         self.XmlSpecification = XmlElement(Item, '%s/XmlSpecification' % Key)
 107         self.Header.FromXml(Item, Key)
 108
 109         DistributionPackageHeader = DistributionPackageHeaderClass()
 110         DistributionPackageHeader.ReadOnly = self.ReadOnly
 111         DistributionPackageHeader.RePackage = self.RePackage
 112         DistributionPackageHeader.Name = self.Header.Name
 113         DistributionPackageHeader.BaseName = self.Header.BaseName
 114         DistributionPackageHeader.Guid = self.Header.GUID
 115         DistributionPackageHeader.Version = self.Header.Version
 116         DistributionPackageHeader.Vendor = self.Vendor
 117         DistributionPackageHeader.Date = self.Date
 118         DistributionPackageHeader.Copyright = self.Header.Copyright
 119         DistributionPackageHeader.License = self.Header.License
 120         DistributionPackageHeader.Abstract = self.Header.Abstract
 121         DistributionPackageHeader.Description = self.Header.Description
 122         DistributionPackageHeader.Signature = self.Signature
 123         DistributionPackageHeader.XmlSpecification = self.XmlSpecification
 124
 125         return DistributionPackageHeader
 126
 127     def ToXml(self, DistributionPackageHeader, Key):
 128         Element1 = CreateXmlElement('Name', DistributionPackageHeader.Name, [], [['BaseName', DistributionPackageHeader.BaseName]])
 129         Element2 = CreateXmlElement('GUID', DistributionPackageHeader.Guid, [], [['Version', DistributionPackageHeader.Version]])
 130         AttributeList = [['ReadOnly', str(DistributionPackageHeader.ReadOnly)], ['RePackage', str(DistributionPackageHeader.RePackage)]]
 131         NodeList = [Element1,
 132                     Element2,
 133                     ['Vendor', DistributionPackageHeader.Vendor],
 134                     ['Date', DistributionPackageHeader.Date],
 135                     ['Copyright', DistributionPackageHeader.Copyright],
 136                     ['License', DistributionPackageHeader.License],
 137                     ['Abstract', DistributionPackageHeader.Abstract],
 138                     ['Description', DistributionPackageHeader.Description],
 139                     ['Signature', DistributionPackageHeader.Signature],
 140                     ['XmlSpecification', DistributionPackageHeader.XmlSpecification],
 141                     ]
 142         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
 143
 144         return Root
 145
 146     def __str__(self):
 147         return "ReadOnly = %s RePackage = %s Vendor = %s Date = %s Signature = %s XmlSpecification = %s %s" \
 148                % (self.ReadOnly, self.RePackage, self.Vendor, self.Date, self.Signature, self.XmlSpecification, self.Header)
 149
 150 # PackageHeaderXml
 151 class PackageHeaderXml(object):
 152     def __init__(self):
 153         self.Header = HeaderXml()
 154         self.PackagePath = ''
 155
 156     def FromXml(self, Item, Key):
 157         self.PackagePath = XmlElement(Item, '%s/PackagePath' % Key)
 158         self.Header.FromXml(Item, Key)
 159
 160         PackageHeader = PackageHeaderClass()
 161         PackageHeader.Name = self.Header.Name
 162         PackageHeader.BaseName = self.Header.BaseName
 163         PackageHeader.Guid = self.Header.GUID
 164         PackageHeader.Version = self.Header.Version
 165         PackageHeader.Copyright = self.Header.Copyright
 166         PackageHeader.License = self.Header.License
 167         PackageHeader.Abstract = self.Header.Abstract
 168         PackageHeader.Description = self.Header.Description
 169         PackageHeader.CombinePath = self.PackagePath
 170
 171         return PackageHeader
 172
 173     def ToXml(self, PackageHeader, Key):
 174         Element1 = CreateXmlElement('Name', PackageHeader.Name, [], [['BaseName', PackageHeader.BaseName]])
 175         Element2 = CreateXmlElement('GUID', PackageHeader.Guid, [], [['Version', PackageHeader.Version]])
 176         AttributeList = []
 177         NodeList = [Element1,
 178                     Element2,
 179                     ['Copyright', PackageHeader.Copyright],
 180                     ['License', PackageHeader.License],
 181                     ['Abstract', PackageHeader.Abstract],
 182                     ['Description', PackageHeader.Description],
 183                     ['PackagePath', PackageHeader.CombinePath],
 184                     ]
 185         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
 186
 187         return Root
 188
 189     def __str__(self):
 190         return "PackagePath = %s %s" \
 191                % (self.PackagePath, self.Header)
 192
 193 # ClonedFromXml
 194 class ClonedFromXml(object):
 195     def __init__(self):
 196         self.GUID = ''
 197         self.Version = ''
 198
 199     def FromXml(self, Item, Key):
 200         self.GUID = XmlElement(Item, '%s/GUID' % Key)
 201         self.Version = XmlAttribute(XmlNode(Item, '%s/GUID' % Key), 'Version')
 202
 203         if self.GUID == '' and self.Version == '':
 204             return None
 205
 206         ClonedFrom = ClonedRecordClass()
 207         ClonedFrom.PackageGuid = self.GUID
 208         ClonedFrom.PackageVersion = self.Version
 209
 210         return ClonedFrom
 211
 212     def ToXml(self, ClonedFrom, Key):
 213         Root = minidom.Document()
 214         Element1 = CreateXmlElement('GUID', ClonedFrom.PackageGuid, [], [['Version', ClonedFrom.PackageVersion]])
 215         AttributeList = []
 216         NodeList = [Element1]
 217         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
 218
 219         return Root
 220
 221     def __str__(self):
 222         return "GUID = %s Version = %s" % (self.GUID, self.Version)
 223
 224 # CommonDefinesXml
 225 class CommonDefinesXml(object):
 226     def __init__(self):
 227         self.Usage = ''
 228         self.SupArchList = ''
 229         self.SupModList = ''
 230         self.FeatureFlag = ''
 231
 232     def FromXml(self, Item, Key):
 233         self.Usage = XmlAttribute(Item, 'Usage')
 234         self.SupArchList = XmlAttribute(Item, 'SupArchList')
 235         self.SupModList = XmlAttribute(Item, 'SupModList')
 236         self.FeatureFlag = XmlAttribute(Item, 'FeatureFlag')
 237
 238     def ToXml(self):
 239         pass
 240
 241     def __str__(self):
 242         return "Usage = %s SupArchList = %s SupModList = %s FeatureFlag = %s" % (self.Usage, self.SupArchList, self.SupModList, self.FeatureFlag)
 243
 244 # HelpTextXml
 245 class HelpTextXml(object):
 246     def __init__(self):
 247         self.HelpText = ''
 248         self.Lang = ''
 249
 250     def FromXml(self, Item, Key):
 251         self.HelpText = XmlElement(Item, 'HelpText')
 252         self.Lang = XmlAttribute(Item, 'Lang')
 253
 254     def ToXml(self, HelpText, Key = 'HelpText'):
 255         return CreateXmlElement('%s' % Key, HelpText.String, [], [['Lang', HelpText.Lang]])
 256
 257     def __str__(self):
 258         return "HelpText = %s Lang = %s" % (self.HelpText, self.Lang)
 259
 260 # LibraryClassXml
 261 class LibraryClassXml(object):
 262     def __init__(self):
 263         self.Keyword = ''
 264         self.HeaderFile = ''
 265         self.RecommendedInstanceGuid = ''
 266         self.RecommendedInstanceVersion = ''
 267         self.CommonDefines = CommonDefinesXml()
 268         self.HelpText = []
 269
 270     def FromXml(self, Item, Key):
 271         self.Keyword = XmlAttribute(XmlNode(Item, '%s' % Key), 'Keyword')
 272         if self.Keyword == '':
 273             self.Keyword = XmlElement(Item, '%s/Keyword' % Key)
 274         self.HeaderFile = XmlElement(Item, '%s/HeaderFile' % Key)
 275         self.RecommendedInstanceGuid = XmlElement(Item, '%s/RecommendedInstance/GUID' % Key)
 276         self.RecommendedInstanceVersion = XmlAttribute(XmlNode(Item, '%s/RecommendedInstance/GUID' % Key), 'Version')
 277         self.CommonDefines.FromXml(XmlNode(Item, '%s' % Key), Key)
 278         for HelpTextItem in XmlList(Item, '%s/HelpText' % Key):
 279             HelpTextObj = HelpTextXml()
 280             HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)
 281             self.HelpText.append(HelpTextObj)
 282
 283         LibraryClass = LibraryClassClass()
 284         LibraryClass.LibraryClass = self.Keyword
 285         LibraryClass.IncludeHeader = self.HeaderFile
 286         LibraryClass.SupArchList = self.CommonDefines.SupArchList
 287         LibraryClass.SupModuleList = self.CommonDefines.SupModList
 288         LibraryClass.RecommendedInstanceGuid = self.RecommendedInstanceGuid
 289         LibraryClass.RecommendedInstanceVersion = self.RecommendedInstanceVersion
 290         LibraryClass.HelpTextList = GetHelpTextList(self.HelpText)
 291
 292         return LibraryClass
 293
 294     def ToXml(self, LibraryClass, Key):
 295         Element1 = CreateXmlElement('GUID', LibraryClass.RecommendedInstanceGuid, [], [['Version', LibraryClass.RecommendedInstanceVersion]])
 296         Element2 = CreateXmlElement('RecommendedInstance', '', [Element1], [])
 297         AttributeList = [['Keyword', LibraryClass.LibraryClass],
 298                          ['SupArchList', GetStringOfList(LibraryClass.SupArchList)],
 299                          ['SupModList', GetStringOfList(LibraryClass.SupModuleList)]
 300                         ]
 301         NodeList = [['HeaderFile', LibraryClass.IncludeHeader],
 302                     Element2
 303                     ]
 304         for Item in LibraryClass.HelpTextList:
 305             Tmp = HelpTextXml()
 306             NodeList.append(Tmp.ToXml(Item))
 307         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
 308
 309         return Root
 310
 311     def __str__(self):
 312         Str = "Keyword = %s HeaderFile = %s RecommendedInstanceGuid = %s RecommendedInstanceVersion = %s %s" \
 313              % (self.Keyword, self.HeaderFile, self.RecommendedInstanceGuid, self.RecommendedInstanceVersion, \
 314                 self.CommonDefines)
 315         for Item in self.HelpText:
 316             Str = Str + "\n\t" + str(Item)
 317         return Str
 318
 319 # IndustryStandardHeaderXml
 320 class IndustryStandardHeaderXml(object):
 321     def __init__(self):
 322         self.HeaderFile = ''
 323         self.HelpText = []
 324
 325     def FromXml(self, Item, Key):
 326         self.HeaderFile = XmlElement(Item, '%s/HeaderFile' % Key)
 327         for HelpTextItem in XmlList(Item, '%s/HelpText' % Key):
 328             HelpTextObj = HelpTextXml()
 329             HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)
 330             self.HelpText.append(HelpTextObj)
 331
 332         Include = IncludeClass()
 333         Include.FilePath = self.HeaderFile
 334         Include.HelpTextList = GetHelpTextList(self.HelpText)
 335
 336         return Include
 337
 338     def ToXml(self, IndustryStandardHeader, Key):
 339         AttributeList = []
 340         NodeList = [['HeaderFile', IndustryStandardHeader.FilePath]]
 341         for Item in IndustryStandardHeader.HelpTextList:
 342             Tmp = HelpTextXml()
 343             NodeList.append(Tmp.ToXml(Item))
 344         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
 345
 346         return Root
 347
 348     def __str__(self):
 349         Str = "HeaderFile = %s" % (self.HeaderFile)
 350         for Item in self.HelpText:
 351             Str = Str + "\n\t" + str(Item)
 352         return Str
 353
 354 # PackageIncludeHeaderXml
 355 class PackageIncludeHeaderXml(object):
 356     def __init__(self):
 357         self.HeaderFile = ''
 358         self.CommonDefines = CommonDefinesXml()
 359         self.HelpText = []
 360
 361     def FromXml(self, Item, Key):
 362         self.HeaderFile = XmlElement(Item, '%s/HeaderFile' % Key)
 363         self.CommonDefines.FromXml(XmlNode(Item, '%s/HeaderFile' % Key), Key)
 364         for HelpTextItem in XmlList(Item, '%s/HelpText' % Key):
 365             HelpTextObj = HelpTextXml()
 366             HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)
 367             self.HelpText.append(HelpTextObj)
 368
 369         Include = IncludeClass()
 370         Include.FilePath = self.HeaderFile
 371         Include.SupArchList = self.CommonDefines.SupArchList
 372         Include.SupModuleList = self.CommonDefines.SupModList
 373         Include.HelpTextList = GetHelpTextList(self.HelpText)
 374
 375         return Include
 376
 377     def ToXml(self, PackageIncludeHeader, Key):
 378         AttributeList = [['SupArchList', PackageIncludeHeader.SupArchList],
 379                          ['SupModList', PackageIncludeHeader.SupModuleList]
 380                         ]
 381         NodeList = [['HeaderFile', PackageIncludeHeader.FilePath]]
 382         for Item in PackageIncludeHeader.HelpTextList:
 383             Tmp = HelpTextXml()
 384             NodeList.append(Tmp.ToXml(Item))
 385         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
 386
 387         return Root
 388
 389     def __str__(self):
 390         Str = "HeaderFile = %s\n\t%s" % (self.HeaderFile, self.CommonDefines)
 391         for Item in self.HelpText:
 392             Str = Str + "\n\t" + str(Item)
 393         return Str
 394
 395 #GUID/Protocol/Ppi
 396 class GuidProtocolPpiXml(object):
 397     def __init__(self):
 398         self.UiName = ''
 399         self.GuidTypes = ''
 400         self.Notify = ''
 401         self.CName = ''
 402         self.GuidValue = ''
 403         self.CommonDefines = CommonDefinesXml()
 404         self.HelpText = []
 405
 406     def FromXml(self, Item, Key):
 407         self.UiName = XmlAttribute(XmlNode(Item, '%s' % Key), 'UiName')
 408         self.GuidTypes = XmlAttribute(XmlNode(Item, '%s' % Key), 'GuidTypes')
 409         self.GuidType = XmlAttribute(XmlNode(Item, '%s' % Key), 'GuidType')
 410         self.Notify = XmlAttribute(XmlNode(Item, '%s' % Key), 'Notify')
 411         self.CName = XmlElement(Item, '%s/CName' % Key)
 412         self.GuidValue = XmlElement(Item, '%s/GuidValue' % Key)
 413         self.VariableName = XmlElement(Item, '%s/VariableName' % Key)
 414         self.CommonDefines.FromXml(XmlNode(Item, '%s' % Key), Key)
 415         for HelpTextItem in XmlList(Item, '%s/HelpText' % Key):
 416             HelpTextObj = HelpTextXml()
 417             HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)
 418             self.HelpText.append(HelpTextObj)
 419
 420         GuidProtocolPpi = GuidProtocolPpiCommonClass()
 421         GuidProtocolPpi.Name = self.UiName
 422         GuidProtocolPpi.CName = self.CName
 423         GuidProtocolPpi.Guid = self.GuidValue
 424         GuidProtocolPpi.VariableName = self.VariableName
 425         GuidProtocolPpi.Notify = self.Notify
 426         GuidProtocolPpi.Usage = self.CommonDefines.Usage
 427         GuidProtocolPpi.FeatureFlag = self.CommonDefines.FeatureFlag
 428         GuidProtocolPpi.SupArchList = self.CommonDefines.SupArchList
 429         GuidProtocolPpi.SupModuleList = self.CommonDefines.SupModList
 430         GuidProtocolPpi.GuidTypeLists = self.GuidTypes
 431         GuidProtocolPpi.GuidTypeList = self.GuidType
 432         GuidProtocolPpi.HelpTextList = GetHelpTextList(self.HelpText)
 433
 434         return GuidProtocolPpi
 435
 436     def ToXml(self, GuidProtocolPpi, Key):
 437         AttributeList = [['Usage', GetStringOfList(GuidProtocolPpi.Usage)],
 438                          ['UiName', GuidProtocolPpi.Name],
 439                          ['GuidTypes', GetStringOfList(GuidProtocolPpi.GuidTypeLists)],
 440                          ['GuidType', GetStringOfList(GuidProtocolPpi.GuidTypeList)],
 441                          ['Notify', str(GuidProtocolPpi.Notify)],
 442                          ['SupArchList', GetStringOfList(GuidProtocolPpi.SupArchList)],
 443                          ['SupModList', GetStringOfList(GuidProtocolPpi.SupModuleList)],
 444                          ['FeatureFlag', GuidProtocolPpi.FeatureFlag]
 445                         ]
 446         NodeList = [['CName', GuidProtocolPpi.CName],
 447                     ['GuidValue', GuidProtocolPpi.Guid],
 448                     ['VariableName', GuidProtocolPpi.VariableName]
 449                    ]
 450         for Item in GuidProtocolPpi.HelpTextList:
 451             Tmp = HelpTextXml()
 452             NodeList.append(Tmp.ToXml(Item))
 453         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
 454
 455         return Root
 456
 457     def __str__(self):
 458         Str = "UiName = %s Notify = %s GuidTypes = %s CName = %s GuidValue = %s %s" \
 459              % (self.UiName, self.Notify, self.GuidTypes, self.CName, self.GuidValue, self.CommonDefines)
 460         for Item in self.HelpText:
 461             Str = Str + "\n\t" + str(Item)
 462         return Str
 463
 464 # PcdErrorXml
 465 class PcdErrorXml(object):
 466     def __init__(self):
 467         self.ValidValueList = ''
 468         self.ValidValueListLang = ''
 469         self.ValidValueRange = ''
 470         self.Expression = ''
 471         self.ErrorNumber = ''
 472         self.ErrorMessage = []
 473
 474     def FromXml(self, Item, Key):
 475         self.ValidValueList = XmlElement(Item, '%s/ValidValueList' % Key)
 476         self.ValidValueListLang = XmlAttribute(XmlNode(Item, '%s/ValidValueList' % Key), 'Lang')
 477         self.ValidValueRange = XmlElement(Item, '%s/ValidValueRange' % Key)
 478         self.Expression = XmlElement(Item, '%s/Expression' % Key)
 479         self.ErrorNumber = XmlElement(Item, '%s/ErrorNumber' % Key)
 480         for ErrMsg in XmlList(Item, '%s/ErrorMessage' % Key):
 481             ErrorMessageString = XmlElement(ErrMsg, 'ErrorMessage')
 482             ErrorMessageLang = XmlAttribute(XmlNode(ErrMsg, 'ErrorMessage'), 'Lang')
 483             self.ErrorMessage.append((ErrorMessageLang, ErrorMessageString))
 484
 485         Error = PcdErrorClass()
 486         Error.ValidValueList = self.ValidValueList
 487         Error.ValidValueListLang = self.ValidValueListLang
 488         Error.ValidValueRange = self.ValidValueRange
 489         Error.Expression = self.Expression
 490         Error.ErrorNumber = self.ErrorNumber
 491         Error.ErrorMessage = self.ErrorMessage
 492
 493         return Error
 494
 495     def ToXml(self, PcdError, Key):
 496         AttributeList = []
 497         Element1 = CreateXmlElement('ValidValueList', PcdError.ValidValueList, [], [['Lang', PcdError.ValidValueListLang]])
 498         NodeList = [Element1,
 499                     ['ValidValueRange', PcdError.ValidValueRange],
 500                     ['Expression', PcdError.Expression],
 501                     ['ErrorNumber', PcdError.ErrorNumber],
 502                    ]
 503         for Item in PcdError.ErrorMessage:
 504             Element = CreateXmlElement('ErrorMessage', Item[1], [], [['Lang', Item[0]]])
 505             NodeList.append(Element)
 506         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
 507
 508         return Root
 509
 510     def __str__(self):
 511         return "ValidValueList = %s ValidValueListLang = %s ValidValueRange = %s Expression = %s ErrorNumber = %s %s" \
 512                % (self.ValidValueList, self.ValidValueListLang, self.ValidValueRange, self.Expression, self.ErrorNumber, self.ErrorMessage)
 513
 514 # PcdEntryXml
 515 class PcdEntryXml(object):
 516     def __init__(self):
 517         self.PcdItemType = ''
 518         self.PcdUsage = ''
 519         self.TokenSpaceGuidCName = ''
 520         self.TokenSpaceGuidValue = ''
 521         self.Token = ''
 522         self.CName = ''
 523         self.PcdCName = ''
 524         self.DatumType = ''
 525         self.ValidUsage = ''
 526         self.DefaultValue = ''
 527         self.MaxDatumSize = ''
 528         self.Value = ''
 529         self.Offset = ''
 530         self.CommonDefines = CommonDefinesXml()
 531         self.HelpText = []
 532         self.PcdError = []
 533
 534     def FromXml(self, Item, Key):
 535         self.PcdItemType = XmlAttribute(XmlNode(Item, '%s' % Key), 'PcdItemType')
 536         self.PcdUsage = XmlAttribute(XmlNode(Item, '%s' % Key), 'PcdUsage')
 537         self.TokenSpaceGuidCName = XmlElement(Item, '%s/TokenSpaceGuidCName' % Key)
 538         self.TokenSpaceGuidValue = XmlElement(Item, '%s/TokenSpaceGuidValue' % Key)
 539         self.Token = XmlElement(Item, '%s/Token' % Key)
 540         self.CName = XmlElement(Item, '%s/CName' % Key)
 541         self.PcdCName = XmlElement(Item, '%s/PcdCName' % Key)
 542         self.DatumType = XmlElement(Item, '%s/DatumType' % Key)
 543         self.ValidUsage = XmlElement(Item, '%s/ValidUsage' % Key)
 544         self.DefaultValue = XmlElement(Item, '%s/DefaultValue' % Key)
 545         self.MaxDatumSize = XmlElement(Item, '%s/MaxDatumSize' % Key)
 546         self.Value = XmlElement(Item, '%s/Value' % Key)
 547         self.Offset = XmlElement(Item, '%s/Offset' % Key)
 548         self.CommonDefines.FromXml(XmlNode(Item, '%s' % Key), Key)
 549         for HelpTextItem in XmlList(Item, '%s/HelpText' % Key):
 550             HelpTextObj = HelpTextXml()
 551             HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)
 552             self.HelpText.append(HelpTextObj)
 553         for PcdErrorItem in XmlList(Item, '%s/PcdError' % Key):
 554             PcdErrorObj = PcdErrorXml()
 555             PcdErrorObj.FromXml(PcdErrorItem, 'PcdError')
 556             self.PcdError.append(PcdErrorObj)
 557
 558         PcdEntry = PcdClass()
 559         PcdEntry.SupArchList = self.CommonDefines.SupArchList
 560         PcdEntry.SupModuleList = self.CommonDefines.SupModList
 561         PcdEntry.TokenSpaceGuidCName = self.TokenSpaceGuidCName
 562         PcdEntry.TokenSpaceGuidValue = self.TokenSpaceGuidValue
 563         PcdEntry.Token = self.Token
 564         PcdEntry.CName = self.CName
 565         PcdEntry.PcdCName = self.PcdCName
 566         PcdEntry.DatumType = self.DatumType
 567         PcdEntry.ValidUsage = self.ValidUsage
 568         PcdEntry.PcdUsage = self.PcdUsage
 569         PcdEntry.Usage = self.CommonDefines.Usage
 570         PcdEntry.DefaultValue = self.DefaultValue
 571         PcdEntry.Value = self.Value
 572         PcdEntry.Offset = self.Offset
 573         PcdEntry.MaxDatumSize = self.MaxDatumSize
 574         PcdEntry.FeatureFlag = self.CommonDefines.FeatureFlag
 575         PcdEntry.PcdItemType = self.PcdItemType
 576         PcdEntry.HelpTextList = GetHelpTextList(self.HelpText)
 577         PcdEntry.PcdErrors = self.PcdError
 578
 579         return PcdEntry
 580
 581     def ToXml(self, PcdEntry, Key):
 582         AttributeList = [['SupArchList', GetStringOfList(PcdEntry.SupArchList)],
 583                          ['PcdUsage', PcdEntry.PcdUsage],
 584                          ['PcdItemType', PcdEntry.PcdItemType],
 585                          ['FeatureFlag', PcdEntry.FeatureFlag],
 586                          ['SupModList', GetStringOfList(PcdEntry.SupModuleList)]
 587                         ]
 588         NodeList = [['TokenSpaceGuidCName', PcdEntry.TokenSpaceGuidCName],
 589                     ['TokenSpaceGuidValue', PcdEntry.TokenSpaceGuidValue],
 590                     ['Token', PcdEntry.Token],
 591                     ['CName', PcdEntry.CName],
 592                     ['PcdCName', PcdEntry.PcdCName],
 593                     ['DatumType', PcdEntry.DatumType],
 594                     ['ValidUsage', GetStringOfList(PcdEntry.ValidUsage)],
 595                     ['DefaultValue', PcdEntry.DefaultValue],
 596                     ['Value', PcdEntry.Value],
 597                     ['Offset', PcdEntry.Offset],
 598                     ['MaxDatumSize', PcdEntry.MaxDatumSize],
 599                    ]
 600         for Item in PcdEntry.HelpTextList:
 601             Tmp = HelpTextXml()
 602             NodeList.append(Tmp.ToXml(Item, 'HelpText'))
 603         for Item in PcdEntry.PcdErrors:
 604             Tmp = PcdErrorXml()
 605             NodeList.append(Tmp.ToXml(Item, 'PcdError'))
 606
 607         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
 608
 609         return Root
 610
 611     def __str__(self):
 612         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" \
 613              % (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)
 614         for Item in self.HelpText:
 615             Str = Str + "\n\t" + str(Item)
 616         for Item in self.PcdError:
 617             Str = Str + "\n\tPcdError:" + str(Item)
 618         return Str
 619
 620 # PcdCheckXml
 621 class PcdCheckXml(object):
 622     def __init__(self):
 623         self.PcdCheck = ''
 624
 625     def FromXml(self, Item, Key):
 626         self.PcdCheck = XmlElement(Item, 'PcdCheck')
 627
 628         return self.PcdCheck
 629
 630     def ToXml(self, PcdCheck, Key):
 631         Root = CreateXmlElement('%s' % Key, PcdCheck, [], [])
 632         return Root
 633
 634     def __str__(self):
 635         return "PcdCheck = %s" % (self.PcdCheck)
 636
 637 # MiscellaneousFileXml
 638 class MiscellaneousFileXml(object):
 639     def __init__(self):
 640         self.Header = HeaderXml()
 641         self.Files = []
 642
 643     def FromXml(self, Item, Key):
 644         self.Header.FromXml(Item, Key)
 645         NewItem = XmlNode(Item, '%s/Header' % Key)
 646         self.Header.FromXml(NewItem, 'Header')
 647
 648         for SubItem in XmlList(Item, '%s/Filename' % Key):
 649             Filename =  XmlElement(SubItem, '%s/Filename' % Key)
 650             Executable = XmlAttribute(XmlNode(SubItem, '%s/Filename' % Key), 'Executable')
 651             self.Files.append([Filename, Executable])
 652
 653         MiscFile = MiscFileClass()
 654         MiscFile.Copyright = self.Header.Copyright
 655         MiscFile.License = self.Header.License
 656         MiscFile.Abstract = self.Header.Abstract
 657         MiscFile.Description = self.Header.Description
 658         for File in self.Files:
 659             FileObj = FileClass()
 660             FileObj.Filename = File[0]
 661             FileObj.Executable = File[1]
 662             MiscFile.Files.append(FileObj)
 663
 664         return MiscFile
 665
 666     def FromXml2(self, Item, Key):
 667         NewItem = XmlNode(Item, '%s/Header' % Key)
 668         self.Header.FromXml(NewItem, 'Header')
 669
 670         for SubItem in XmlList(Item, '%s/Filename' % Key):
 671             Filename =  XmlElement(SubItem, '%s/Filename' % Key)
 672             Executable = XmlAttribute(XmlNode(SubItem, '%s/Filename' % Key), 'Executable')
 673             self.Files.append([Filename, Executable])
 674
 675         MiscFile = MiscFileClass()
 676         MiscFile.Name = self.Header.Name
 677         MiscFile.Copyright = self.Header.Copyright
 678         MiscFile.License = self.Header.License
 679         MiscFile.Abstract = self.Header.Abstract
 680         MiscFile.Description = self.Header.Description
 681         for File in self.Files:
 682             FileObj = FileClass()
 683             FileObj.Filename = File[0]
 684             FileObj.Executable = File[1]
 685             MiscFile.Files.append(FileObj)
 686
 687         return MiscFile
 688
 689
 690     def ToXml(self, MiscFile, Key):
 691         if MiscFile:
 692             NodeList = [['Copyright', MiscFile.Copyright],
 693                         ['License', MiscFile.License],
 694                         ['Abstract', MiscFile.Abstract],
 695                         ['Description', MiscFile.Description],
 696                        ]
 697             if MiscFile != None:
 698                 for File in MiscFile.Files:
 699                     NodeList.append(CreateXmlElement('Filename', File.Filename, [], [['Executable', File.Executable]]))
 700                 Root = CreateXmlElement('%s' % Key, '', NodeList, [])
 701
 702                 return Root
 703
 704     def ToXml2(self, MiscFile, Key):
 705         if MiscFile:
 706             NodeList = [['Name', MiscFile.Name],
 707                         ['Copyright', MiscFile.Copyright],
 708                         ['License', MiscFile.License],
 709                         ['Abstract', MiscFile.Abstract],
 710                         ['Description', MiscFile.Description],
 711                        ]
 712             HeaderNode = CreateXmlElement('Header', '', NodeList, [])
 713             NodeList = [HeaderNode]
 714
 715             for File in MiscFile.Files:
 716                 NodeList.append(CreateXmlElement('Filename', File.Filename, [], [['Executable', File.Executable]]))
 717             Root = CreateXmlElement('%s' % Key, '', NodeList, [])
 718
 719             return Root
 720
 721     def __str__(self):
 722         Str = str(self.Header)
 723         for Item in self.Files:
 724             Str = Str + '\n\tFilename:' + str(Item)
 725         return Str
 726
 727 # UserExtensionsXml
 728 class UserExtensionsXml(object):
 729     def __init__(self):
 730         self.UserId = ''
 731         self.Identifier = ''
 732         self.Defines = []
 733         self.BuildOptions = []
 734
 735     def FromXml(self, Item, Key):
 736         self.UserId = XmlAttribute(XmlNode(Item, '%s' % Key), 'UserId')
 737         self.Identifier = XmlAttribute(XmlNode(Item, '%s' % Key), 'Identifier')
 738         for SubItem in XmlList(Item, '%s/Define' % Key):
 739             self.Defines.append(XmlElement(SubItem, '%s/Define' % Key))
 740         for SubItem in XmlList(Item, '%s/BuildOption' % Key):
 741             self.BuildOptions.append(XmlElement(SubItem, '%s/BuildOption' % Key))
 742
 743         UserExtension = UserExtensionsClass()
 744         UserExtension.UserID = self.UserId
 745         UserExtension.Identifier = self.Identifier
 746         UserExtension.Defines = self.Defines
 747         UserExtension.BuildOptions = self.BuildOptions
 748
 749         return UserExtension
 750
 751     def ToXml(self, UserExtension, Key):
 752         AttributeList = [['UserId', str(UserExtension.UserID)],
 753                          ['Identifier', str(UserExtension.Identifier)]
 754                         ]
 755         NodeList = []
 756         for Item in UserExtension.Defines:
 757             NodeList.append(['Define', Item])
 758         for Item in UserExtension.BuildOptions:
 759             NodeList.append(['BuildOption', Item])
 760         Root = CreateXmlElement('%s' % Key, UserExtension.Content, NodeList, AttributeList)
 761
 762         return Root
 763
 764     def __str__(self):
 765         Str = "UserId = %s Identifier = %s" % (self.UserId, self.Identifier)
 766         Str = Str + '\n\tDefines:' + str(self.Defines)
 767         Str = Str + '\n\tBuildOptions:' + str(self.BuildOptions)
 768         return Str
 769
 770 # BootModeXml
 771 class BootModeXml(object):
 772     def __init__(self):
 773         self.SupportedBootModes = ''
 774         self.CommonDefines = CommonDefinesXml()
 775         self.HelpText = []
 776
 777     def FromXml(self, Item, Key):
 778         self.SupportedBootModes = XmlElement(Item, '%s/SupportedBootModes' % Key)
 779         self.CommonDefines.FromXml(Item, Key)
 780         for HelpTextItem in XmlList(Item, '%s/HelpText' % Key):
 781             HelpTextObj = HelpTextXml()
 782             HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)
 783             self.HelpText.append(HelpTextObj)
 784
 785         BootMode = ModuleBootModeClass()
 786         BootMode.Name = self.SupportedBootModes
 787         BootMode.SupArchList = self.CommonDefines.SupArchList
 788         BootMode.Usage = self.CommonDefines.Usage
 789         BootMode.FeatureFlag = self.CommonDefines.FeatureFlag
 790         BootMode.HelpTextList = GetHelpTextList(self.HelpText)
 791
 792         return BootMode
 793
 794     def ToXml(self, BootMode, Key):
 795         AttributeList = [['Usage', BootMode.Usage],
 796                          ['SupArchList', GetStringOfList(BootMode.SupArchList)],
 797                          ['FeatureFlag', BootMode.FeatureFlag],
 798                         ]
 799         NodeList = [['SupportedBootModes', BootMode.Name]]
 800         for Item in BootMode.HelpTextList:
 801             Tmp = HelpTextXml()
 802             NodeList.append(Tmp.ToXml(Item, 'HelpText'))
 803         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
 804
 805         return Root
 806
 807     def __str__(self):
 808         Str = "SupportedBootModes = %s %s" % (self.SupportedBootModes, self.CommonDefines)
 809         for Item in self.HelpText:
 810             Str = Str + '\n\t' + str(Item)
 811         return Str
 812
 813 # EventXml
 814 class EventXml(object):
 815     def __init__(self):
 816         self.EventType = ''
 817         self.Name = ''
 818         self.CommonDefines = CommonDefinesXml()
 819         self.HelpText = []
 820
 821     def FromXml(self, Item, Key):
 822         self.EventType = XmlAttribute(XmlNode(Item, '%s' % Key), 'EventType')
 823         self.Name = XmlElement(Item, '%s' % Key)
 824         self.CommonDefines.FromXml(Item, Key)
 825         for HelpTextItem in XmlList(Item, '%s/HelpText' % Key):
 826             HelpTextObj = HelpTextXml()
 827             HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)
 828             self.HelpText.append(HelpTextObj)
 829
 830         Event = ModuleEventClass()
 831         Event.Type = self.EventType
 832         Event.GuidCName = self.Name
 833         Event.SupArchList = self.CommonDefines.SupArchList
 834         Event.Usage = self.CommonDefines.Usage
 835         Event.FeatureFlag = self.CommonDefines.FeatureFlag
 836         Event.HelpTextList = GetHelpTextList(self.HelpText)
 837
 838         return Event
 839
 840     def ToXml(self, Event, Key):
 841         AttributeList = [['EventType', Event.Type],
 842                          ['Usage', Event.Usage],
 843                          ['SupArchList', GetStringOfList(Event.SupArchList)],
 844                          ['FeatureFlag', Event.FeatureFlag],
 845                         ]
 846         NodeList = []
 847         for Item in Event.HelpTextList:
 848             Tmp = HelpTextXml()
 849             NodeList.append(Tmp.ToXml(Item, 'HelpText'))
 850         Root = CreateXmlElement('%s' % Key, Event.GuidCName, NodeList, AttributeList)
 851
 852         return Root
 853
 854     def __str__(self):
 855         Str = "EventType = %s %s" % (self.EventType, self.CommonDefines)
 856         for Item in self.HelpText:
 857             Str = Str + '\n\t' + str(Item)
 858         return Str
 859
 860 # HobXml
 861 class HobXml(object):
 862     def __init__(self):
 863         self.HobType = ''
 864         self.Name = ''
 865         self.CommonDefines = CommonDefinesXml()
 866         self.HelpText = []
 867
 868     def FromXml(self, Item, Key):
 869         self.HobType = XmlAttribute(XmlNode(Item, '%s' % Key), 'HobType')
 870         self.Name = XmlElement(Item, '%s' % Key)
 871         self.CommonDefines.FromXml(Item, Key)
 872         for HelpTextItem in XmlList(Item, '%s/HelpText' % Key):
 873             HelpTextObj = HelpTextXml()
 874             HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)
 875             self.HelpText.append(HelpTextObj)
 876
 877         Hob = ModuleHobClass()
 878         Hob.Type = self.HobType
 879         Hob.GuidCName = self.Name
 880         Hob.SupArchList = self.CommonDefines.SupArchList
 881         Hob.Usage = self.CommonDefines.Usage
 882         Hob.FeatureFlag = self.CommonDefines.FeatureFlag
 883         Hob.HelpTextList = GetHelpTextList(self.HelpText)
 884
 885         return Hob
 886
 887     def ToXml(self, Hob, Key):
 888         AttributeList = [['EventType', Hob.Type],
 889                          ['Usage', Hob.Usage],
 890                          ['SupArchList', GetStringOfList(Hob.SupArchList)],
 891                          ['FeatureFlag', Hob.FeatureFlag],
 892                         ]
 893         NodeList = []
 894         for Item in Hob.HelpTextList:
 895             Tmp = HelpTextXml()
 896             NodeList.append(Tmp.ToXml(Item, 'HelpText'))
 897         Root = CreateXmlElement('%s' % Key, Hob.GuidCName, NodeList, AttributeList)
 898
 899         return Root
 900
 901     def __str__(self):
 902         Str = "HobType = %s %s" % (self.HobType, self.CommonDefines)
 903         for Item in self.HelpText:
 904             Str = Str + '\n\t' + str(Item)
 905         return Str
 906
 907 # ModulePropertyXml
 908 class ModulePropertyXml(object):
 909     def __init__(self):
 910         self.CommonDefines = CommonDefinesXml()
 911         self.ModuleType = ''
 912         self.Path = ''
 913         self.PcdIsDriver = ''
 914         self.UefiSpecificationVersion = ''
 915         self.PiSpecificationVersion = ''
 916         self.Specification = ''
 917         self.SpecificationVersion = ''
 918         self.BootModes = []
 919         self.Events = []
 920         self.HOBs = []
 921
 922     def FromXml(self, Item, Key, Header = None):
 923         self.CommonDefines.FromXml(Item, Key)
 924         self.ModuleType = XmlElement(Item, '%s/ModuleType' % Key)
 925         self.Path = XmlElement(Item, '%s/Path' % Key)
 926         self.PcdIsDriver = XmlElement(Item, '%s/PcdIsDriver' % Key)
 927         self.UefiSpecificationVersion = XmlElement(Item, '%s/UefiSpecificationVersion' % Key)
 928         self.PiSpecificationVersion = XmlElement(Item, '%s/PiSpecificationVersion' % Key)
 929         self.Specification = XmlElement(Item, '%s/Specification' % Key)
 930         self.SpecificationVersion = XmlAttribute(XmlNode(Item, '%s/Specification' % Key), 'Version')
 931         for SubItem in XmlList(Item, '%s/BootMode' % Key):
 932             A = BootModeXml()
 933             BootMode = A.FromXml(SubItem, 'BootMode')
 934             self.BootModes.append(BootMode)
 935         for SubItem in XmlList(Item, '%s/Event' % Key):
 936             A = EventXml()
 937             Event = A.FromXml(SubItem, 'Event')
 938             self.Events.append(Event)
 939         for SubItem in XmlList(Item, '%s/HOB' % Key):
 940             A = HobXml()
 941             Hob = A.FromXml(SubItem, 'HOB')
 942             self.HOBs.append(Hob)
 943
 944         if Header == None:
 945             Header = ModuleHeaderClass()
 946
 947         Header.ModuleType = self.ModuleType
 948         Header.SupArchList = self.CommonDefines.SupArchList
 949         Header.SupModuleList = self.CommonDefines.SupModList
 950         Header.CombinePath = self.Path
 951         Header.PcdIsDriver = self.PcdIsDriver
 952         Header.UefiSpecificationVersion = self.UefiSpecificationVersion
 953         Header.PiSpecificationVersion = self.PiSpecificationVersion
 954
 955         return Header, self.BootModes, self.Events, self.HOBs
 956
 957
 958     def ToXml(self, Header, BootModes, Events, Hobs, Key):
 959         AttributeList = [['SupArchList', GetStringOfList(Header.SupArchList)],
 960                          ['SupModList', GetStringOfList(Header.SupModuleList)],
 961                         ]
 962         NodeList = [['ModuleType', Header.ModuleType],
 963                     ['Path', Header.CombinePath],
 964                     ['PcdIsDriver', Header.PcdIsDriver],
 965                     ['UefiSpecificationVersion', Header.UefiSpecificationVersion],
 966                     ['PiSpecificationVersion', Header.PiSpecificationVersion],
 967                    ]
 968         for Item in BootModes:
 969             Tmp = BootModeXml()
 970             NodeList.append(Tmp.ToXml(Item, 'BootMode'))
 971         for Item in Events:
 972             Tmp = EventXml()
 973             NodeList.append(Tmp.ToXml(Item, 'Event'))
 974         for Item in Hobs:
 975             Tmp = HobXml()
 976             NodeList.append(Tmp.ToXml(Item, 'Hob'))
 977         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
 978
 979         return Root
 980
 981     def __str__(self):
 982         Str = "ModuleType = %s Path = %s PcdIsDriver = %s UefiSpecificationVersion = %s PiSpecificationVersion = %s Specification = %s SpecificationVersion = %s %s" \
 983                 % (self.ModuleType, self.Path, self.PcdIsDriver, self.UefiSpecificationVersion, self.PiSpecificationVersion, \
 984                    self.Specification, self.SpecificationVersion, self.CommonDefines)
 985         for Item in self.BootModes:
 986             Str = Str + '\n\t' + str(Item)
 987         for Item in self.Events:
 988             Str = Str + '\n\t' + str(Item)
 989         for Item in self.HOBs:
 990             Str = Str + '\n\t' + str(Item)
 991         return Str
 992
 993 # SourceFileXml
 994 class SourceFileXml(object):
 995     def __init__(self):
 996         self.SourceFile = ''
 997         self.ToolChainFamily = ''
 998         self.FileType = ''
 999         self.CommonDefines = CommonDefinesXml()
1000
1001     def FromXml(self, Item, Key):
1002         self.ToolChainFamily = XmlAttribute(Item, 'Family')
1003         self.FileType = XmlAttribute(Item, 'FileType')
1004         self.SourceFile = XmlElement(Item, 'Filename')
1005         self.CommonDefines.FromXml(Item, Key)
1006
1007         SourceFile = ModuleSourceFileClass()
1008         SourceFile.SourceFile = self.SourceFile
1009         SourceFile.FileType = self.FileType
1010         SourceFile.ToolChainFamily = self.ToolChainFamily
1011         SourceFile.SupArchList = self.CommonDefines.SupArchList
1012         SourceFile.FeatureFlag = self.CommonDefines.FeatureFlag
1013
1014         return SourceFile
1015
1016     def ToXml(self, SourceFile, Key):
1017         AttributeList = [['SupArchList', GetStringOfList(SourceFile.SupArchList)],
1018                          ['Family', SourceFile.ToolChainFamily],
1019                          ['FileType', SourceFile.FileType],
1020                          ['FeatureFlag', SourceFile.FeatureFlag],
1021                         ]
1022         Root = CreateXmlElement('%s' % Key, SourceFile.SourceFile, [], AttributeList)
1023
1024         return Root
1025
1026 # FilenameXml
1027 class FilenameXml(object):
1028     def __init__(self):
1029         self.OS = ''
1030         self.Family = ''
1031         self.FileType = ''
1032         self.Filename = ''
1033         self.Executable = ''
1034         self.CommonDefines = CommonDefinesXml()
1035
1036     def FromXml(self, Item, Key):
1037         self.OS = XmlAttribute(Item, 'OS')
1038         self.Family = XmlAttribute(Item, 'Family')
1039         self.FileType = XmlAttribute(Item, 'FileType')
1040         self.Filename = XmlElement(Item, 'Filename')
1041         self.Executable = XmlElement(Item, 'Executable')
1042         self.CommonDefines.FromXml(Item, Key)
1043
1044         Filename = FileClass()
1045         Filename.Family = self.Family
1046         Filename.FileType = self.FileType
1047         Filename.Filename = self.Filename
1048         Filename.Executable = self.Executable
1049         Filename.SupArchList = self.CommonDefines.SupArchList
1050         Filename.FeatureFlag = self.CommonDefines.FeatureFlag
1051
1052         return Filename
1053
1054     def ToXml(self, Filename, Key):
1055         AttributeList = [['SupArchList', GetStringOfList(Filename.SupArchList)],
1056                          ['Family', Filename.Family],
1057                          ['FileType', Filename.FileType],
1058                          ['Executable', Filename.Executable],
1059                          ['FeatureFlag', Filename.FeatureFlag],
1060                         ]
1061         NodeList = [['Filename', Filename.Filename],
1062                    ]
1063         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
1064
1065         return Root
1066
1067     def __str__(self):
1068         return "OS = %s Family = %s FileType = %s Filename = %s Executable = %s %s" \
1069              % (self.OS, self.Family, self.FileType, self.Filename, self.Executable, self.CommonDefines)
1070
1071 class BinaryFileXml(object):
1072     def __init__(self):
1073         self.Filenames = []
1074         self.PatchPcdValues = []
1075         self.PcdExValues = []
1076         self.LibraryInstances = []
1077         self.BuildFlags = []
1078
1079     def FromXml(self, Item, Key):
1080         BinaryFile = ModuleBinaryFileClass()
1081         for SubItem in XmlList(Item, '%s/Filename' % Key):
1082             A = FilenameXml()
1083             B = A.FromXml(SubItem, 'Filename')
1084             BinaryFile.Filenames.append(B)
1085         for SubItem in XmlList(Item, '%s/AsBuilt/PatchPcdValue' % Key):
1086             A = PcdEntryXml()
1087             B = A.FromXml(SubItem, 'PatchPcdValue')
1088             BinaryFile.PatchPcdValues.append(B)
1089         for SubItem in XmlList(Item, '%s/AsBuilt/PcdExValue' % Key):
1090             A = PcdEntryXml()
1091             B = A.FromXml(SubItem, 'PcdExValue')
1092             BinaryFile.PatchPcdValues.append(B)
1093         for SubItem in XmlList(Item, '%s/AsBuilt/LibraryInstances/GUID' % Key):
1094             GUID = XmlElement(SubItem, 'GUID')
1095             Version = XmlAttribute(XmlNode(SubItem, 'GUID'), 'Version')
1096             BinaryFile.LibraryInstances.append([GUID, Version])
1097         for SubItem in XmlList(Item, '%s/AsBuilt/BuildFlags' % Key):
1098             BinaryFile.BuildFlags.append(XmlElement(SubItem, 'BuildFlags'))
1099
1100         return BinaryFile
1101
1102     def ToXml(self, BinaryFile, Key):
1103         NodeList = []
1104         for Item in BinaryFile.Filenames:
1105             Tmp = FilenameXml()
1106             NodeList.append(Tmp.ToXml(Item, 'Filename'))
1107         AsBuiltNodeList = []
1108         for Item in BinaryFile.PatchPcdValues:
1109             Tmp = PcdEntryXml()
1110             AsBuiltNodeList.append(Tmp.ToXml(Item, 'PatchPcdValue'))
1111         for Item in BinaryFile.PcdExValues:
1112             Tmp = PcdEntryXml()
1113             AsBuiltNodeList.append(Tmp.ToXml(Item, 'PcdExValue'))
1114         LibNodeList = []
1115         for Item in BinaryFile.LibraryInstances:
1116             LibNode = CreateXmlElement('GUID', Item[0], [], [['Version', Item[1]]])
1117             LibNodeList.append(LibNode)
1118         if LibNodeList:
1119             AsBuiltNodeList.append(CreateXmlElement('LibraryInstances', '', LibNodeList, []))
1120         for Item in BinaryFile.BuildFlags:
1121             AsBuiltNodeList.append(CreateXmlElement('BuildFlags', Item, [], []))
1122         Element = CreateXmlElement('AsBuilt', '', AsBuiltNodeList, [])
1123         NodeList.append(Element)
1124
1125         Root = CreateXmlElement('%s' % Key, '', NodeList, [])
1126
1127         return Root
1128
1129     def __str__(self):
1130         Str = "BinaryFiles:"
1131         for Item in self.Filenames:
1132             Str = Str + '\n\t' + str(Item)
1133         for Item in self.PatchPcdValues:
1134             Str = Str + '\n\t' + str(Item)
1135         for Item in self.PcdExValues:
1136             Str = Str + '\n\t' + str(Item)
1137         for Item in self.LibraryInstances:
1138             Str = Str + '\n\t' + str(Item)
1139         for Item in self.BuildFlags:
1140             Str = Str + '\n\t' + str(Item)
1141         return Str
1142
1143 # PackageXml
1144 class PackageXml(object):
1145     def __init__(self):
1146         self.Description = ''
1147         self.Guid = ''
1148         self.Version = ''
1149         self.CommonDefines = CommonDefinesXml()
1150
1151     def FromXml(self, Item, Key):
1152         self.Description = XmlElement(Item, '%s/Description' % Key)
1153         self.Guid = XmlElement(Item, '%s/GUID' % Key)
1154         self.Version = XmlAttribute(XmlNode(Item, '%s/GUID' % Key), 'Version')
1155         self.CommonDefines.FromXml(XmlNode(Item, '%s' % Key), Key)
1156
1157         PackageDependency = ModulePackageDependencyClass()
1158         PackageDependency.FilePath = self.Description
1159         PackageDependency.PackageGuid = self.Guid
1160         PackageDependency.PackageVersion = self.Version
1161         PackageDependency.FeatureFlag = self.CommonDefines.FeatureFlag
1162         PackageDependency.SupArchList = self.CommonDefines.SupArchList
1163
1164         return PackageDependency
1165
1166     def ToXml(self, PackageDependency, Key):
1167         AttributeList = [['SupArchList', GetStringOfList(PackageDependency.SupArchList)],
1168                          ['FeatureFlag', PackageDependency.FeatureFlag],
1169                         ]
1170         Element1 = CreateXmlElement('GUID', PackageDependency.PackageGuid, [], [['Version', PackageDependency.PackageVersion]])
1171         NodeList = [['Description', PackageDependency.FilePath],
1172                     Element1,
1173                    ]
1174
1175         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
1176
1177         return Root
1178
1179     def __str__(self):
1180         Str = "Description = %s Guid = %s Version = %s %s" \
1181              % (self.Description, self.Guid, self.Version, self.CommonDefines)
1182         return Str
1183
1184 # ExternXml
1185 class ExternXml(object):
1186     def __init__(self):
1187         self.CommonDefines = CommonDefinesXml()
1188         self.EntryPoint = ''
1189         self.UnloadImage = ''
1190         self.Constructor = ''
1191         self.Destructor = ''
1192         self.HelpText = []
1193
1194     def FromXml(self, Item, Key):
1195         self.CommonDefines.FromXml(Item, Key)
1196         self.EntryPoint = XmlElement(Item, '%s/EntryPoint' % Key)
1197         self.UnloadImage = XmlElement(Item, '%s/UnloadImage' % Key)
1198         self.Constructor = XmlElement(Item, '%s/Constructor' % Key)
1199         self.Destructor = XmlElement(Item, '%s/Destructor' % Key)
1200         for HelpTextItem in XmlList(Item, '%s/HelpText' % Key):
1201             HelpTextObj = HelpTextXml()
1202             HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)
1203             self.HelpText.append(HelpTextObj)
1204
1205         Extern = ModuleExternClass()
1206         Extern.EntryPoint = self.EntryPoint
1207         Extern.UnloadImage = self.UnloadImage
1208         Extern.Constructor = self.Constructor
1209         Extern.Destructor = self.Destructor
1210         Extern.SupArchList = self.CommonDefines.SupArchList
1211         Extern.FeatureFlag = self.CommonDefines.FeatureFlag
1212         Extern.HelpTextList = GetHelpTextList(self.HelpText)
1213
1214         return Extern
1215
1216     def ToXml(self, Extern, Key):
1217         AttributeList = [['SupArchList', GetStringOfList(Extern.SupArchList)],
1218                          ['FeatureFlag', Extern.FeatureFlag],
1219                         ]
1220         NodeList = [['EntryPoint', Extern.EntryPoint],
1221                     ['UnloadImage', Extern.UnloadImage],
1222                     ['Constructor', Extern.Constructor],
1223                     ['Destructor', Extern.Destructor],
1224                    ]
1225         for Item in Extern.HelpTextList:
1226             Tmp = HelpTextXml()
1227             NodeList.append(Tmp.ToXml(Item, 'HelpText'))
1228
1229         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
1230
1231         return Root
1232
1233     def __str__(self):
1234         Str = "EntryPoint = %s UnloadImage = %s Constructor = %s Destructor = %s %s" \
1235              % (self.EntryPoint, self.UnloadImage, self.Constructor, self.Destructor, self.CommonDefines)
1236         for Item in self.HelpText:
1237             Str = Str + '\n\t' + str(Item)
1238         return Str
1239 # DepexXml
1240 class DepexXml(object):
1241     def __init__(self):
1242         self.Expression = ''
1243         #self.HelpText = HelpTextXml()
1244         self.HelpText = []
1245
1246     def FromXml(self, Item, Key):
1247         self.Expression = XmlElement(Item, '%s/Expression' % Key)
1248         for HelpTextItem in XmlList(Item, '%s/HelpText' % Key):
1249             HelpTextObj = HelpTextXml()
1250             HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)
1251             self.HelpText.append(HelpTextObj)
1252
1253         Depex = ModuleDepexClass()
1254         Depex.Depex = self.Expression
1255         Depex.HelpTextList = GetHelpTextList(self.HelpText)
1256
1257         return Depex
1258
1259     def ToXml(self, Depex, Key):
1260         AttributeList = []
1261         NodeList = [['Expression', Depex.Depex],
1262                    ]
1263         for Item in Depex.HelpTextList:
1264             Tmp = HelpTextXml()
1265             NodeList.append(Tmp.ToXml(Item, 'HelpText'))
1266
1267         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
1268
1269         return Root
1270
1271     def __str__(self):
1272         Str = "Expression = %s" % (self.Expression)
1273         for Item in self.HelpText:
1274             Str = Str + '\n\t' + str(Item)
1275         return Str
1276
1277 # PackageSurfaceAreaXml
1278 class PackageSurfaceAreaXml(object):
1279     def __init__(self):
1280         self.Package = None
1281
1282     def FromXml(self, Item, Key):
1283         # Create a package object
1284         Package = PackageClass()
1285
1286         # Header
1287         Tmp = PackageHeaderXml()
1288         PackageHeader = Tmp.FromXml(XmlNode(Item, '/PackageSurfaceArea/Header'), 'Header')
1289         Package.PackageHeader = PackageHeader
1290
1291         # ClonedFrom
1292         Tmp = ClonedFromXml()
1293         ClonedFrom = Tmp.FromXml(XmlNode(Item, '/PackageSurfaceArea/ClonedFrom'), 'ClonedFrom')
1294         if ClonedFrom:
1295             Package.PackageHeader.ClonedFrom.append(ClonedFrom)
1296
1297         # LibraryClass
1298         for SubItem in XmlList(Item, '/PackageSurfaceArea/LibraryClassDeclarations/LibraryClass'):
1299             Tmp = LibraryClassXml()
1300             LibraryClass = Tmp.FromXml(SubItem, 'LibraryClass')
1301             Package.LibraryClassDeclarations.append(LibraryClass)
1302
1303         # IndustryStandardHeader
1304         for SubItem in XmlList(Item, '/PackageSurfaceArea/IndustryStandardIncludes/IndustryStandardHeader'):
1305             Tmp = IndustryStandardHeaderXml()
1306             Include = Tmp.FromXml(SubItem, 'IndustryStandardHeader')
1307             Package.IndustryStdHeaders.append(Include)
1308
1309         # PackageHeader
1310         for SubItem in XmlList(Item, '/PackageSurfaceArea/PackageIncludes/PackageHeader'):
1311             Tmp = PackageIncludeHeaderXml()
1312             Include = Tmp.FromXml(SubItem, 'PackageHeader')
1313             Package.PackageIncludePkgHeaders.append(Include)
1314
1315         # Guid
1316         for SubItem in XmlList(Item, '/PackageSurfaceArea/GuidDeclarations/Entry'):
1317             Tmp = GuidProtocolPpiXml()
1318             GuidProtocolPpi = Tmp.FromXml(SubItem, 'Entry')
1319             Package.GuidDeclarations.append(GuidProtocolPpi)
1320
1321         # Protocol
1322         for SubItem in XmlList(Item, '/PackageSurfaceArea/ProtocolDeclarations/Entry'):
1323             Tmp = GuidProtocolPpiXml()
1324             GuidProtocolPpi = Tmp.FromXml(SubItem, 'Entry')
1325             Package.ProtocolDeclarations.append(GuidProtocolPpi)
1326
1327         # Ppi
1328         for SubItem in XmlList(Item, '/PackageSurfaceArea/PpiDeclarations/Entry'):
1329             Tmp = GuidProtocolPpiXml()
1330             GuidProtocolPpi = Tmp.FromXml(SubItem, 'Entry')
1331             Package.PpiDeclarations.append(GuidProtocolPpi)
1332
1333         # PcdEntry
1334         for SubItem in XmlList(Item, '/PackageSurfaceArea/PcdDeclarations/PcdEntry'):
1335             Tmp = PcdEntryXml()
1336             PcdEntry = Tmp.FromXml(SubItem, 'PcdEntry')
1337             Package.PcdDeclarations.append(PcdEntry)
1338
1339         # PcdCheck
1340         for SubItem in XmlList(Item, '/PackageSurfaceArea/PcdRelationshipChecks/PcdCheck'):
1341             Tmp = PcdCheckXml()
1342             PcdCheck = Tmp.FromXml(SubItem, 'PcdCheck')
1343             Package.PcdChecks.append(PcdCheck)
1344
1345         # MiscellaneousFile
1346         Tmp = MiscellaneousFileXml()
1347         Package.MiscFiles = Tmp.FromXml(XmlNode(Item, '/PackageSurfaceArea/MiscellaneousFiles'), 'MiscellaneousFiles')
1348
1349         # UserExtensions
1350         Tmp = UserExtensionsXml()
1351         Package.UserExtensions = Tmp.FromXml(XmlNode(Item, '/PackageSurfaceArea/UserExtensions'), 'UserExtensions')
1352
1353         # Modules
1354         for SubItem in XmlList(Item, '/PackageSurfaceArea/Modules/ModuleSurfaceArea'):
1355             Tmp = ModuleSurfaceAreaXml()
1356             Module = Tmp.FromXml(SubItem, 'ModuleSurfaceArea')
1357             Package.Modules[(Module.ModuleHeader.Guid, Module.ModuleHeader.Version, Module.ModuleHeader.CombinePath)] = Module
1358
1359         self.Package = Package
1360         return self.Package
1361
1362     def ToXml(self, Package):
1363         # Create PackageSurfaceArea node
1364         DomPackage = minidom.Document().createElement('PackageSurfaceArea')
1365
1366         # Header
1367         Tmp = PackageHeaderXml()
1368         DomPackage.appendChild(Tmp.ToXml(Package.PackageHeader, 'Header'))
1369
1370         # ClonedFrom
1371         Tmp = ClonedFromXml()
1372         if Package.PackageHeader.ClonedFrom != []:
1373             DomPackage.appendChild(Tmp.ToXml(Package.PackageHeader.ClonedFrom[0], 'ClonedFrom'))
1374
1375         # LibraryClass
1376         LibraryClassNode = CreateXmlElement('LibraryClassDeclarations', '', [], [])
1377         for LibraryClass in Package.LibraryClassDeclarations:
1378             Tmp = LibraryClassXml()
1379             LibraryClassNode.appendChild(Tmp.ToXml(LibraryClass, 'LibraryClass'))
1380         DomPackage.appendChild(LibraryClassNode)
1381
1382         # IndustryStandardHeader
1383         IndustryStandardHeaderNode = CreateXmlElement('IndustryStandardIncludes', '', [], [])
1384         for Include in Package.IndustryStdHeaders:
1385             Tmp = IndustryStandardHeaderXml()
1386             IndustryStandardHeaderNode.appendChild(Tmp.ToXml(Include, 'IndustryStandardHeader'))
1387         DomPackage.appendChild(IndustryStandardHeaderNode)
1388
1389         # PackageHeader
1390         PackageIncludeHeaderNode = CreateXmlElement('PackageIncludes', '', [], [])
1391         for Include in Package.PackageIncludePkgHeaders:
1392             Tmp = PackageIncludeHeaderXml()
1393             PackageIncludeHeaderNode.appendChild(Tmp.ToXml(Include, 'PackageHeader'))
1394         DomPackage.appendChild(PackageIncludeHeaderNode)
1395
1396         # Guid
1397         GuidProtocolPpiNode = CreateXmlElement('GuidDeclarations', '', [], [])
1398         for GuidProtocolPpi in Package.GuidDeclarations:
1399             Tmp = GuidProtocolPpiXml()
1400             GuidProtocolPpiNode.appendChild(Tmp.ToXml(GuidProtocolPpi, 'Entry'))
1401         DomPackage.appendChild(GuidProtocolPpiNode)
1402
1403         # Protocol
1404         GuidProtocolPpiNode = CreateXmlElement('ProtocolDeclarations', '', [], [])
1405         for GuidProtocolPpi in Package.ProtocolDeclarations:
1406             Tmp = GuidProtocolPpiXml()
1407             GuidProtocolPpiNode.appendChild(Tmp.ToXml(GuidProtocolPpi, 'Entry'))
1408         DomPackage.appendChild(GuidProtocolPpiNode)
1409
1410         # Ppi
1411         GuidProtocolPpiNode = CreateXmlElement('PpiDeclarations', '', [], [])
1412         for GuidProtocolPpi in Package.PpiDeclarations:
1413             Tmp = GuidProtocolPpiXml()
1414             GuidProtocolPpiNode.appendChild(Tmp.ToXml(GuidProtocolPpi, 'Entry'))
1415         DomPackage.appendChild(GuidProtocolPpiNode)
1416
1417         # PcdEntry
1418         PcdEntryNode = CreateXmlElement('PcdDeclarations', '', [], [])
1419         for PcdEntry in Package.PcdDeclarations:
1420             Tmp = PcdEntryXml()
1421             PcdEntryNode.appendChild(Tmp.ToXml(PcdEntry, 'PcdEntry'))
1422         DomPackage.appendChild(PcdEntryNode)
1423
1424         # PcdCheck
1425         PcdCheckNode = CreateXmlElement('PcdRelationshipChecks', '', [], [])
1426         for PcdCheck in Package.PcdChecks:
1427             Tmp = PcdCheckXml()
1428             PcdCheckNode.appendChild(Tmp.ToXml(PcdCheck, 'PcdCheck'))
1429         DomPackage.appendChild(PcdCheckNode)
1430
1431         # MiscellaneousFile
1432         Tmp = MiscellaneousFileXml()
1433         DomPackage.appendChild(Tmp.ToXml(Package.MiscFiles, 'MiscellaneousFiles'))
1434
1435         # UserExtensions
1436         Tmp = UserExtensionsXml()
1437         DomPackage.appendChild(Tmp.ToXml(Package.UserExtensions, 'UserExtensions'))
1438
1439         # Modules
1440         ModuleNode = CreateXmlElement('Modules', '', [], [])
1441         for Module in Package.Modules.values():
1442             Tmp = ModuleSurfaceAreaXml()
1443             ModuleNode.appendChild(Tmp.ToXml(Module))
1444         DomPackage.appendChild(ModuleNode)
1445
1446         return DomPackage
1447
1448 # ModuleXml
1449 class ModuleSurfaceAreaXml(object):
1450     def __init__(self):
1451         self.Module = None
1452
1453     def FromXml(self, Item, Key):
1454         # Create a package object
1455         Module = ModuleClass()
1456
1457         # Header
1458         Tmp = HeaderXml()
1459         ModuleHeader = Tmp.FromXml(XmlNode(Item, '/ModuleSurfaceArea/Header'), 'Header')
1460         Module.ModuleHeader = ModuleHeader
1461
1462         # ModuleProperties
1463         Tmp = ModulePropertyXml()
1464         (Header, BootModes, Events, HOBs) = Tmp.FromXml(XmlNode(Item, '/ModuleSurfaceArea/ModuleProperties'), 'ModuleProperties', ModuleHeader)
1465         Module.ModuleHeader = Header
1466         Module.BootModes = BootModes
1467         Module.Events = Events
1468         Module.Hobs = HOBs
1469
1470         # ClonedFrom
1471         Tmp = ClonedFromXml()
1472         ClonedFrom = Tmp.FromXml(XmlNode(Item, '/ModuleSurfaceArea/ClonedFrom'), 'ClonedFrom')
1473         if ClonedFrom:
1474             Module.ModuleHeader.ClonedFrom.append(ClonedFrom)
1475
1476         # LibraryClass
1477         #LibraryClassNode = CreateXmlElement('LibraryClassDefinitions', '', [], [])
1478         for SubItem in XmlList(Item, '/ModuleSurfaceArea/LibraryClassDefinitions/LibraryClass'):
1479             Tmp = LibraryClassXml()
1480             LibraryClass = Tmp.FromXml(SubItem, 'LibraryClass')
1481             Module.LibraryClasses.append(LibraryClass)
1482
1483         # SourceFile
1484         #SourceFileNode = CreateXmlElement('SourceFiles', '', [], [])
1485         for SubItem in XmlList(Item, '/ModuleSurfaceArea/SourceFiles/Filename'):
1486             Tmp = SourceFileXml()
1487             SourceFile = Tmp.FromXml(SubItem, 'Filename')
1488             Module.Sources.append(SourceFile)
1489
1490         # BinaryFile
1491         #BinaryFileNode = CreateXmlElement('BinaryFiles', '', [], [])
1492         for SubItem in XmlList(Item, '/ModuleSurfaceArea/BinaryFiles/BinaryFile'):
1493             Tmp = BinaryFileXml()
1494             BinaryFile = Tmp.FromXml(SubItem, 'BinaryFile')
1495             Module.Binaries.append(BinaryFile)
1496
1497         # PackageDependencies
1498         #PackageDependencyNode = CreateXmlElement('PackageDependencies', '', [], [])
1499         for SubItem in XmlList(Item, '/ModuleSurfaceArea/PackageDependencies/Package'):
1500             Tmp = PackageXml()
1501             PackageDependency = Tmp.FromXml(SubItem, 'Package')
1502             Module.PackageDependencies.append(PackageDependency)
1503
1504         # Guid
1505         #GuidProtocolPpiNode = CreateXmlElement('Guids', '', [], [])
1506         for SubItem in XmlList(Item, '/ModuleSurfaceArea/Guids/GuidCName'):
1507             Tmp = GuidProtocolPpiXml()
1508             GuidProtocolPpi = Tmp.FromXml(SubItem, 'GuidCName')
1509             Module.Guids.append(GuidProtocolPpi)
1510
1511         # Protocol
1512         #GuidProtocolPpiNode = CreateXmlElement('Protocols', '', [], [])
1513         for SubItem in XmlList(Item, '/ModuleSurfaceArea/Protocols/Protocol'):
1514             Tmp = GuidProtocolPpiXml()
1515             GuidProtocolPpi = Tmp.FromXml(SubItem, 'Protocol')
1516             Module.Protocols.append(GuidProtocolPpi)
1517
1518         # Ppi
1519         #GuidProtocolPpiNode = CreateXmlElement('PPIs', '', [], [])
1520         for SubItem in XmlList(Item, '/ModuleSurfaceArea/PPIs/Ppi'):
1521             Tmp = GuidProtocolPpiXml()
1522             GuidProtocolPpi = Tmp.FromXml(SubItem, 'Ppi')
1523             Module.Ppis.append(GuidProtocolPpi)
1524
1525         # Extern
1526         #ExternNode = CreateXmlElement('Externs', '', [], [])
1527         for SubItem in XmlList(Item, '/ModuleSurfaceArea/Externs/Extern'):
1528             Tmp = ExternXml()
1529             Extern = Tmp.FromXml(SubItem, 'Extern')
1530             Module.Externs.append(Extern)
1531
1532         # PcdCoded
1533         #PcdEntryNode = CreateXmlElement('PcdCoded', '', [], [])
1534         for SubItem in XmlList(Item, '/ModuleSurfaceArea/PcdCoded/PcdEntry'):
1535             Tmp = PcdEntryXml()
1536             PcdEntry = Tmp.FromXml(SubItem, 'PcdEntry')
1537             Module.PcdCodes.append(PcdEntry)
1538
1539         # PeiDepex
1540         #DepexNode = CreateXmlElement('PeiDepex', '', [], [])
1541         Tmp = DepexXml()
1542         Module.PeiDepex = Tmp.FromXml(XmlNode(Item, '/ModuleSurfaceArea/PeiDepex'), 'PeiDepex')
1543
1544         # DxeDepex
1545         #DepexNode = CreateXmlElement('DxeDepex', '', [], [])
1546         Tmp = DepexXml()
1547         Module.DxeDepex = Tmp.FromXml(XmlNode(Item, '/ModuleSurfaceArea/DxeDepex'), 'DxeDepex')
1548
1549         # SmmDepex
1550         #DepexNode = CreateXmlElement('SmmDepex', '', [], [])
1551         Tmp = DepexXml()
1552         Module.SmmDepex = Tmp.FromXml(XmlNode(Item, '/ModuleSurfaceArea/DxeDepex'), 'SmmDepex')
1553
1554         # MiscellaneousFile
1555         Tmp = MiscellaneousFileXml()
1556         Module.MiscFiles = Tmp.FromXml(XmlNode(Item, '/ModuleSurfaceArea/MiscellaneousFiles'), 'MiscellaneousFiles')
1557
1558         # UserExtensions
1559         Tmp = UserExtensionsXml()
1560         Module.UserExtensions = Tmp.FromXml(XmlNode(Item, '/ModuleSurfaceArea/UserExtensions'), 'UserExtensions')
1561
1562         # return the module object
1563         self.Module = Module
1564         return self.Module
1565
1566     def ToXml(self, Module):
1567         # Create root node of module surface area
1568         DomModule = minidom.Document().createElement('ModuleSurfaceArea')
1569
1570         # Header
1571         Tmp = HeaderXml()
1572         DomModule.appendChild(Tmp.ToXml(Module.ModuleHeader, 'Header'))
1573
1574         # ModuleProperties
1575         Tmp = ModulePropertyXml()
1576         DomModule.appendChild(Tmp.ToXml(Module.ModuleHeader, Module.BootModes, Module.Events, Module.Hobs, 'ModuleProperties'))
1577
1578         # ClonedFrom
1579         Tmp = ClonedFromXml()
1580         if Module.ModuleHeader.ClonedFrom != []:
1581             DomModule.appendChild(Tmp.ToXml(Module.ModuleHeader.ClonedFrom[0], 'ClonedFrom'))
1582
1583         # LibraryClass
1584         LibraryClassNode = CreateXmlElement('LibraryClassDefinitions', '', [], [])
1585         for LibraryClass in Module.LibraryClasses:
1586             Tmp = LibraryClassXml()
1587             LibraryClassNode.appendChild(Tmp.ToXml(LibraryClass, 'LibraryClass'))
1588         DomModule.appendChild(LibraryClassNode)
1589
1590         # SourceFile
1591         SourceFileNode = CreateXmlElement('SourceFiles', '', [], [])
1592         for SourceFile in Module.Sources:
1593             Tmp = SourceFileXml()
1594             SourceFileNode.appendChild(Tmp.ToXml(SourceFile, 'Filename'))
1595         DomModule.appendChild(SourceFileNode)
1596
1597         # BinaryFile
1598         BinaryFileNode = CreateXmlElement('BinaryFiles', '', [], [])
1599         for BinaryFile in Module.Binaries:
1600             Tmp = BinaryFileXml()
1601             BinaryFileNode.appendChild(Tmp.ToXml(BinaryFile, 'BinaryFile'))
1602         DomModule.appendChild(BinaryFileNode)
1603
1604         # PackageDependencies
1605         PackageDependencyNode = CreateXmlElement('PackageDependencies', '', [], [])
1606         for PackageDependency in Module.PackageDependencies:
1607             Tmp = PackageXml()
1608             PackageDependencyNode.appendChild(Tmp.ToXml(PackageDependency, 'Package'))
1609         DomModule.appendChild(PackageDependencyNode)
1610
1611         # Guid
1612         GuidProtocolPpiNode = CreateXmlElement('Guids', '', [], [])
1613         for GuidProtocolPpi in Module.Guids:
1614             Tmp = GuidProtocolPpiXml()
1615             GuidProtocolPpiNode.appendChild(Tmp.ToXml(GuidProtocolPpi, 'GuidCName'))
1616         DomModule.appendChild(GuidProtocolPpiNode)
1617
1618         # Protocol
1619         GuidProtocolPpiNode = CreateXmlElement('Protocols', '', [], [])
1620         for GuidProtocolPpi in Module.Protocols:
1621             Tmp = GuidProtocolPpiXml()
1622             GuidProtocolPpiNode.appendChild(Tmp.ToXml(GuidProtocolPpi, 'Protocol'))
1623         DomModule.appendChild(GuidProtocolPpiNode)
1624
1625         # Ppi
1626         GuidProtocolPpiNode = CreateXmlElement('PPIs', '', [], [])
1627         for GuidProtocolPpi in Module.Ppis:
1628             Tmp = GuidProtocolPpiXml()
1629             GuidProtocolPpiNode.appendChild(Tmp.ToXml(GuidProtocolPpi, 'Ppi'))
1630         DomModule.appendChild(GuidProtocolPpiNode)
1631
1632         # Extern
1633         ExternNode = CreateXmlElement('Externs', '', [], [])
1634         for Extern in Module.Externs:
1635             Tmp = ExternXml()
1636             ExternNode.appendChild(Tmp.ToXml(Extern, 'Extern'))
1637         DomModule.appendChild(ExternNode)
1638
1639         # PcdCoded
1640         PcdEntryNode = CreateXmlElement('PcdCoded', '', [], [])
1641         for PcdEntry in Module.PcdCodes:
1642             Tmp = PcdEntryXml()
1643             PcdEntryNode.appendChild(Tmp.ToXml(PcdEntry, 'PcdEntry'))
1644         DomModule.appendChild(PcdEntryNode)
1645
1646         # PeiDepex
1647         if Module.PeiDepex:
1648             DepexNode = CreateXmlElement('PeiDepex', '', [], [])
1649             Tmp = DepexXml()
1650             DomModule.appendChild(Tmp.ToXml(Module.PeiDepex, 'PeiDepex'))
1651
1652         # DxeDepex
1653         if Module.DxeDepex:
1654             DepexNode = CreateXmlElement('DxeDepex', '', [], [])
1655             Tmp = DepexXml()
1656             DomModule.appendChild(Tmp.ToXml(Module.DxeDepex, 'DxeDepex'))
1657
1658         # SmmDepex
1659         if Module.SmmDepex:
1660             DepexNode = CreateXmlElement('SmmDepex', '', [], [])
1661             Tmp = DepexXml()
1662             DomModule.appendChild(Tmp.ToXml(Module.SmmDepex, 'SmmDepex'))
1663
1664         # MiscellaneousFile
1665         Tmp = MiscellaneousFileXml()
1666         DomModule.appendChild(Tmp.ToXml(Module.MiscFiles, 'MiscellaneousFiles'))
1667
1668         # UserExtensions
1669         Tmp = UserExtensionsXml()
1670         DomModule.appendChild(Tmp.ToXml(Module.UserExtensions, 'UserExtensions'))
1671
1672         return DomModule
1673
1674 # DistributionPackageXml
1675 class DistributionPackageXml(object):
1676     def __init__(self):
1677         self.Dp = DistributionPackageClass()
1678
1679     def FromXml(self, Filename = None):
1680         if Filename != None:
1681             self.Dp = DistributionPackageClass()
1682
1683             # Load to XML
1684             self.Pkg = XmlParseFile(Filename)
1685
1686             # Parse Header information
1687             Tmp = DistributionPackageHeaderXml()
1688             DistributionPackageHeader = Tmp.FromXml(XmlNode(self.Pkg, '/DistributionPackage/DistributionHeader'), 'DistributionHeader')
1689             self.Dp.Header = DistributionPackageHeader
1690
1691             # Parse each PackageSurfaceArea
1692             for Item in XmlList(self.Pkg, '/DistributionPackage/PackageSurfaceArea'):
1693                 Psa = PackageSurfaceAreaXml()
1694                 Package = Psa.FromXml(Item, 'PackageSurfaceArea')
1695                 self.Dp.PackageSurfaceArea[(Package.PackageHeader.Guid, Package.PackageHeader.Version, Package.PackageHeader.CombinePath)] = Package
1696
1697             # Parse each ModuleSurfaceArea
1698             for Item in XmlList(self.Pkg, '/DistributionPackage/ModuleSurfaceArea'):
1699                 Msa = ModuleSurfaceAreaXml()
1700                 Module = Msa.FromXml(Item, 'ModuleSurfaceArea')
1701                 self.Dp.ModuleSurfaceArea[(Module.ModuleHeader.Guid, Module.ModuleHeader.Version, Module.ModuleHeader.CombinePath)] = Module
1702
1703             # Parse Tools
1704             Tmp = MiscellaneousFileXml()
1705             self.Dp.Tools = Tmp.FromXml2(XmlNode(self.Pkg, '/DistributionPackage/Tools'), 'Tools')
1706
1707             # Parse MiscFiles
1708             Tmp = MiscellaneousFileXml()
1709             self.Dp.MiscellaneousFiles = Tmp.FromXml2(XmlNode(self.Pkg, '/DistributionPackage/MiscellaneousFiles'), 'MiscellaneousFiles')
1710
1711             return self.Dp
1712
1713     def ToXml(self, Dp):
1714         if Dp != None:
1715             # Parse DistributionPackageHeader
1716             Attrs = [['xmlns', 'http://www.uefi.org/2008/2.1'],
1717                      ['xmlns:xsi', 'http:/www.w3.org/2001/XMLSchema-instance'],
1718                      ]
1719             Root = CreateXmlElement('DistributionPackage', '', [], Attrs)
1720
1721             Tmp = DistributionPackageHeaderXml()
1722             Root.appendChild(Tmp.ToXml(Dp.Header, 'DistributionHeader'))
1723
1724             # Parse each PackageSurfaceArea
1725             for Package in Dp.PackageSurfaceArea.values():
1726                 Psa = PackageSurfaceAreaXml()
1727                 DomPackage = Psa.ToXml(Package)
1728                 Root.appendChild(DomPackage)
1729
1730             # Parse each ModuleSurfaceArea
1731             for Module in Dp.ModuleSurfaceArea.values():
1732                 Msa = ModuleSurfaceAreaXml()
1733                 DomModule = Msa.ToXml(Module)
1734                 Root.appendChild(DomModule)
1735
1736             # Parse Tools
1737             Tmp = MiscellaneousFileXml()
1738             #Tools = Tmp.FromXml2(XmlNode(self.Pkg, '/DistributionPackage/Tools'), 'Tools')
1739             Root.appendChild(Tmp.ToXml2(Dp.Tools, 'Tools'))
1740
1741             # Parse MiscFiles
1742             Tmp = MiscellaneousFileXml()
1743             #Tools = Tmp.FromXml2(XmlNode(self.Pkg, '/DistributionPackage/MiscellaneousFiles'), 'MiscellaneousFiles')
1744             Root.appendChild(Tmp.ToXml2(Dp.MiscellaneousFiles, 'MiscellaneousFiles'))
1745
1746             return Root.toprettyxml(indent = '  ')
1747
1748         return ''
1749
1750 if __name__ == '__main__':
1751     M = DistributionPackageXml()
1752     M.FromXml('C:\Test.xml')
1753     print M.ToXml(M.Dp)
1754