BaseTools/Source/Python/UPT/Xml/CommonXml.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 CommonXml
  17 '''
  18
  19 ##
  20 # Import Modules
  21 #
  22
  23 from Core.DistributionPackageClass import DistributionPackageHeaderObject
  24 from Library.String import ConvertNEToNOTEQ
  25 from Library.String import ConvertNOTEQToNE
  26 from Library.String import GetSplitValueList
  27 from Library.String import GetStringOfList
  28 from Library.Xml.XmlRoutines import XmlElement
  29 from Library.Xml.XmlRoutines import XmlElement2
  30 from Library.Xml.XmlRoutines import XmlAttribute
  31 from Library.Xml.XmlRoutines import XmlNode
  32 from Library.Xml.XmlRoutines import XmlList
  33 from Library.Xml.XmlRoutines import CreateXmlElement
  34 from Object.POM.CommonObject import FileObject
  35 from Object.POM.CommonObject import MiscFileObject
  36 from Object.POM.CommonObject import UserExtensionObject
  37 from Object.POM.CommonObject import ClonedRecordObject
  38 from Object.POM.CommonObject import LibraryClassObject
  39 from Object.POM.CommonObject import FileNameObject
  40 from Object.POM.ModuleObject import ModuleObject
  41 from Xml.XmlParserMisc import IsRequiredItemListNull
  42 from Xml.XmlParserMisc import GetHelpTextList
  43
  44 import Library.DataType as DataType
  45
  46 ##
  47 # ClonedFromXml
  48 #
  49 class ClonedFromXml(object):
  50     def __init__(self):
  51         self.GUID = ''
  52         self.Version = ''
  53
  54     def FromXml(self, Item, Key):
  55         self.GUID = XmlElement(Item, '%s/GUID' % Key)
  56         self.Version = XmlAttribute(XmlNode(Item, '%s/GUID' % Key), 'Version')
  57
  58         if self.GUID == '' and self.Version == '':
  59             return None
  60
  61         ClonedFrom = ClonedRecordObject()
  62         ClonedFrom.SetPackageGuid(self.GUID)
  63         ClonedFrom.SetPackageVersion(self.Version)
  64
  65         return ClonedFrom
  66
  67     def ToXml(self, ClonedFrom, Key):
  68         if self.GUID:
  69             pass
  70         Element1 = CreateXmlElement('GUID', ClonedFrom.GetPackageGuid(), [],
  71                                     [['Version', ClonedFrom.GetPackageVersion()]])
  72         AttributeList = []
  73         NodeList = [Element1]
  74         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
  75
  76         return Root
  77
  78     def __str__(self):
  79         return "GUID = %s Version = %s" % (self.GUID, self.Version)
  80
  81
  82 ##
  83 # CommonDefinesXml
  84 #
  85 class CommonDefinesXml(object):
  86     def __init__(self):
  87         self.Usage = ''
  88         self.SupArchList = []
  89         self.SupModList = []
  90         self.FeatureFlag = ''
  91
  92     def FromXml(self, Item, Key):
  93         if Key:
  94             pass
  95         self.Usage = XmlAttribute(Item, 'Usage')
  96         self.SupArchList = \
  97         [Arch for Arch in GetSplitValueList(XmlAttribute(Item, 'SupArchList'), DataType.TAB_SPACE_SPLIT) if Arch]
  98         self.SupModList = \
  99         [Mod for Mod in GetSplitValueList(XmlAttribute(Item, 'SupModList'), DataType.TAB_SPACE_SPLIT) if Mod]
 100         self.FeatureFlag = ConvertNOTEQToNE(XmlAttribute(Item, 'FeatureFlag'))
 101
 102
 103     def ToXml(self):
 104         pass
 105
 106     def __str__(self):
 107         return "Usage = %s SupArchList = %s SupModList = %s FeatureFlag = %s" \
 108                 % (self.Usage, self.SupArchList, self.SupModList, self.FeatureFlag)
 109
 110
 111 ##
 112 # HelpTextXml
 113 #
 114 class HelpTextXml(object):
 115     def __init__(self):
 116         self.HelpText = ''
 117         self.Lang = ''
 118
 119     def FromXml(self, Item, Key):
 120         if Key:
 121             pass
 122         self.HelpText = XmlElement2(Item, 'HelpText')
 123         self.Lang = XmlAttribute(Item, 'Lang')
 124
 125     def ToXml(self, HelpText, Key='HelpText'):
 126         if self.HelpText:
 127             pass
 128         return CreateXmlElement('%s' % Key, HelpText.GetString(), [], [['Lang', HelpText.GetLang()]])
 129     def __str__(self):
 130         return "HelpText = %s Lang = %s" % (self.HelpText, self.Lang)
 131
 132 ##
 133 # HeaderXml
 134 #
 135 class HeaderXml(object):
 136     def __init__(self):
 137         self.Name = ''
 138         self.BaseName = ''
 139         self.GUID = ''
 140         self.Version = ''
 141         self.Copyright = ''
 142         self.License = ''
 143         self.Abstract = ''
 144         self.Description = ''
 145
 146     def FromXml(self, Item, Key, IsRequiredCheck=False, IsStandAlongModule=False):
 147         if not Item and IsRequiredCheck:
 148             XmlTreeLevel = []
 149             if IsStandAlongModule:
 150                 XmlTreeLevel = ['DistributionPackage', 'ModuleSurfaceArea']
 151             else:
 152                 XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'ModuleSurfaceArea']
 153             CheckDict = {'Header':''}
 154             IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 155         self.Name = XmlElement(Item, '%s/Name' % Key)
 156         self.BaseName = XmlAttribute(XmlNode(Item, '%s/Name' % Key), 'BaseName')
 157         self.GUID = XmlElement(Item, '%s/GUID' % Key)
 158         self.Version = XmlAttribute(XmlNode(Item, '%s/GUID' % Key), 'Version')
 159         self.Copyright = XmlElement(Item, '%s/Copyright' % Key)
 160         self.License = XmlElement(Item, '%s/License' % Key)
 161         self.Abstract = XmlElement(Item, '%s/Abstract' % Key)
 162         self.Description = XmlElement(Item, '%s/Description' % Key)
 163
 164         ModuleHeader = ModuleObject()
 165         ModuleHeader.SetName(self.Name)
 166         ModuleHeader.SetBaseName(self.BaseName)
 167         ModuleHeader.SetGuid(self.GUID)
 168         ModuleHeader.SetVersion(self.Version)
 169         ModuleHeader.SetCopyright(self.Copyright)
 170         ModuleHeader.SetLicense(self.License)
 171         ModuleHeader.SetAbstract(self.Abstract)
 172         ModuleHeader.SetDescription(self.Description)
 173
 174         return ModuleHeader
 175
 176     def ToXml(self, Header, Key):
 177         if self.GUID:
 178             pass
 179         Element1 = CreateXmlElement('Name', Header.GetName(), [], [['BaseName', Header.GetBaseName()]])
 180         Element2 = CreateXmlElement('GUID', Header.GetGuid(), [], [['Version', Header.GetVersion()]])
 181         AttributeList = []
 182         NodeList = [Element1,
 183                     Element2,
 184                     ['Copyright', Header.GetCopyright()],
 185                     ['License', Header.GetLicense()],
 186                     ['Abstract', Header.GetAbstract()],
 187                     ['Description', Header.GetDescription()],
 188                     ]
 189         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
 190
 191         return Root
 192
 193     def __str__(self):
 194         return "Name = %s BaseName = %s GUID = %s Version = %s Copyright = %s \
 195         License = %s Abstract = %s Description = %s" % \
 196         (self.Name, self.BaseName, self.GUID, self.Version, self.Copyright, \
 197          self.License, self.Abstract, self.Description)
 198 ##
 199 # DistributionPackageHeaderXml
 200 #
 201 class DistributionPackageHeaderXml(object):
 202     def __init__(self):
 203         self.Header = HeaderXml()
 204         self.ReadOnly = ''
 205         self.RePackage = ''
 206         self.Vendor = ''
 207         self.Date = ''
 208         self.Signature = ''
 209         self.XmlSpecification = ''
 210
 211     def FromXml(self, Item, Key):
 212         if not Item:
 213             return None
 214         self.ReadOnly = XmlAttribute(XmlNode(Item, '%s' % Key), 'ReadOnly')
 215         self.RePackage = XmlAttribute(XmlNode(Item, '%s' % Key), 'RePackage')
 216         self.Vendor = XmlElement(Item, '%s/Vendor' % Key)
 217         self.Date = XmlElement(Item, '%s/Date' % Key)
 218         self.Signature = XmlElement(Item, '%s/Signature' % Key)
 219         self.XmlSpecification = XmlElement(Item, '%s/XmlSpecification' % Key)
 220         self.Header.FromXml(Item, Key)
 221
 222         DistributionPackageHeader = DistributionPackageHeaderObject()
 223         if self.ReadOnly.upper() == 'TRUE':
 224             DistributionPackageHeader.ReadOnly = True
 225         elif self.ReadOnly.upper() == 'FALSE':
 226             DistributionPackageHeader.ReadOnly = False
 227
 228         if self.RePackage.upper() == 'TRUE':
 229             DistributionPackageHeader.RePackage = True
 230         elif self.RePackage.upper() == 'FALSE':
 231             DistributionPackageHeader.RePackage = False
 232         DistributionPackageHeader.Vendor = self.Vendor
 233         DistributionPackageHeader.Date = self.Date
 234         DistributionPackageHeader.Signature = self.Signature
 235         DistributionPackageHeader.XmlSpecification = self.XmlSpecification
 236
 237         DistributionPackageHeader.SetName(self.Header.Name)
 238         DistributionPackageHeader.SetBaseName(self.Header.BaseName)
 239         DistributionPackageHeader.SetGuid(self.Header.GUID)
 240         DistributionPackageHeader.SetVersion(self.Header.Version)
 241         DistributionPackageHeader.SetCopyright(self.Header.Copyright)
 242         DistributionPackageHeader.SetLicense(self.Header.License)
 243         DistributionPackageHeader.SetAbstract(self.Header.Abstract)
 244         DistributionPackageHeader.SetDescription(self.Header.Description)
 245
 246         return DistributionPackageHeader
 247
 248     def ToXml(self, DistributionPackageHeader, Key):
 249         if self.Header:
 250             pass
 251         Element1 = CreateXmlElement('Name', \
 252                                     DistributionPackageHeader.GetName(), [], \
 253                                     [['BaseName', \
 254                                     DistributionPackageHeader.GetBaseName()]])
 255         Element2 = CreateXmlElement('GUID', \
 256                                     DistributionPackageHeader.GetGuid(), [], \
 257                                     [['Version', \
 258                                     DistributionPackageHeader.GetVersion()]])
 259         AttributeList = []
 260         if DistributionPackageHeader.ReadOnly != '':
 261             AttributeList.append(['ReadOnly', str(DistributionPackageHeader.ReadOnly).lower()])
 262         if DistributionPackageHeader.RePackage != '':
 263             AttributeList.append(['RePackage', str(DistributionPackageHeader.RePackage).lower()])
 264
 265         NodeList = [Element1,
 266                     Element2,
 267                     ['Vendor', DistributionPackageHeader.Vendor],
 268                     ['Date', DistributionPackageHeader.Date],
 269                     ['Copyright', DistributionPackageHeader.GetCopyright()],
 270                     ['License', DistributionPackageHeader.GetLicense()],
 271                     ['Abstract', DistributionPackageHeader.GetAbstract()],
 272                     ['Description', \
 273                      DistributionPackageHeader.GetDescription()],
 274                     ['Signature', DistributionPackageHeader.Signature],
 275                     ['XmlSpecification', \
 276                      DistributionPackageHeader.XmlSpecification],
 277                     ]
 278         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
 279
 280         return Root
 281
 282     def __str__(self):
 283         return "ReadOnly = %s RePackage = %s Vendor = %s Date = %s \
 284         Signature = %s XmlSpecification = %s %s" % \
 285         (self.ReadOnly, self.RePackage, self.Vendor, self.Date, \
 286          self.Signature, self.XmlSpecification, self.Header)
 287 ##
 288 # PackageHeaderXml
 289 #
 290 class PackageHeaderXml(object):
 291     def __init__(self):
 292         self.Header = HeaderXml()
 293         self.PackagePath = ''
 294
 295     def FromXml(self, Item, Key, PackageObject2):
 296         if not Item:
 297             XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea']
 298             CheckDict = {'PackageHeader':None, }
 299             IsRequiredItemListNull(CheckDict, XmlTreeLevel)
 300         self.PackagePath = XmlElement(Item, '%s/PackagePath' % Key)
 301         self.Header.FromXml(Item, Key)
 302
 303         PackageObject2.SetName(self.Header.Name)
 304         PackageObject2.SetBaseName(self.Header.BaseName)
 305         PackageObject2.SetGuid(self.Header.GUID)
 306         PackageObject2.SetVersion(self.Header.Version)
 307         PackageObject2.SetCopyright(self.Header.Copyright)
 308         PackageObject2.SetLicense(self.Header.License)
 309         PackageObject2.SetAbstract(self.Header.Abstract)
 310         PackageObject2.SetDescription(self.Header.Description)
 311         PackageObject2.SetPackagePath(self.PackagePath)
 312
 313     def ToXml(self, PackageObject2, Key):
 314         if self.PackagePath:
 315             pass
 316         Element1 = \
 317         CreateXmlElement('Name', PackageObject2.GetName(), [], \
 318                          [['BaseName', PackageObject2.GetBaseName()]])
 319         Element2 = CreateXmlElement('GUID', PackageObject2.GetGuid(), [], \
 320                                     [['Version', PackageObject2.GetVersion()]])
 321         AttributeList = []
 322         NodeList = [Element1,
 323                     Element2,
 324                     ['Copyright', PackageObject2.GetCopyright()],
 325                     ['License', PackageObject2.GetLicense()],
 326                     ['Abstract', PackageObject2.GetAbstract()],
 327                     ['Description', PackageObject2.GetDescription()],
 328                     ['PackagePath', PackageObject2.GetPackagePath()],
 329                     ]
 330         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
 331
 332         return Root
 333
 334     def __str__(self):
 335         return "PackagePath = %s %s" \
 336                % (self.PackagePath, self.Header)
 337
 338 ##
 339 # MiscellaneousFileXml
 340 #
 341 class MiscellaneousFileXml(object):
 342     def __init__(self):
 343         self.Header = HeaderXml()
 344         self.Files = []
 345     ##
 346     # This API is used for Package or Module's MiscellaneousFile section
 347     #
 348     def FromXml(self, Item, Key):
 349         if not Item:
 350             return None
 351         self.Header.FromXml(Item, Key)
 352         NewItem = XmlNode(Item, '%s/Header' % Key)
 353         self.Header.FromXml(NewItem, 'Header')
 354
 355         for SubItem in XmlList(Item, '%s/Filename' % Key):
 356             Filename = XmlElement(SubItem, '%s/Filename' % Key)
 357             Executable = XmlAttribute(XmlNode(SubItem, '%s/Filename' % Key), 'Executable')
 358             if Executable.upper() == "TRUE":
 359                 Executable = True
 360             else:
 361                 Executable = False
 362             self.Files.append([Filename, Executable])
 363
 364         MiscFile = MiscFileObject()
 365         MiscFile.SetCopyright(self.Header.Copyright)
 366         MiscFile.SetLicense(self.Header.License)
 367         MiscFile.SetAbstract(self.Header.Abstract)
 368         MiscFile.SetDescription(self.Header.Description)
 369         MiscFileList = []
 370         for File in self.Files:
 371             FileObj = FileObject()
 372             FileObj.SetURI(File[0])
 373             FileObj.SetExecutable(File[1])
 374             MiscFileList.append(FileObj)
 375         MiscFile.SetFileList(MiscFileList)
 376
 377         return MiscFile
 378     ##
 379     # This API is used for DistP's tool section
 380     #
 381     def FromXml2(self, Item, Key):
 382         if Item is None:
 383             return None
 384
 385         NewItem = XmlNode(Item, '%s/Header' % Key)
 386         self.Header.FromXml(NewItem, 'Header')
 387
 388         for SubItem in XmlList(Item, '%s/Filename' % Key):
 389             Filename = XmlElement(SubItem, '%s/Filename' % Key)
 390             Executable = \
 391             XmlAttribute(XmlNode(SubItem, '%s/Filename' % Key), 'Executable')
 392             OsType = XmlAttribute(XmlNode(SubItem, '%s/Filename' % Key), 'OS')
 393             if Executable.upper() == "TRUE":
 394                 Executable = True
 395             else:
 396                 Executable = False
 397             self.Files.append([Filename, Executable, OsType])
 398
 399         MiscFile = MiscFileObject()
 400         MiscFile.SetName(self.Header.Name)
 401         MiscFile.SetCopyright(self.Header.Copyright)
 402         MiscFile.SetLicense(self.Header.License)
 403         MiscFile.SetAbstract(self.Header.Abstract)
 404         MiscFile.SetDescription(self.Header.Description)
 405         MiscFileList = []
 406         for File in self.Files:
 407             FileObj = FileObject()
 408             FileObj.SetURI(File[0])
 409             FileObj.SetExecutable(File[1])
 410             FileObj.SetOS(File[2])
 411             MiscFileList.append(FileObj)
 412         MiscFile.SetFileList(MiscFileList)
 413
 414         return MiscFile
 415
 416     ##
 417     # This API is used for Package or Module's MiscellaneousFile section
 418     #
 419     def ToXml(self, MiscFile, Key):
 420         if self.Header:
 421             pass
 422         if MiscFile:
 423             NodeList = [['Copyright', MiscFile.GetCopyright()],
 424                         ['License', MiscFile.GetLicense()],
 425                         ['Abstract', MiscFile.GetAbstract()],
 426                         ['Description', MiscFile.GetDescription()],
 427                        ]
 428
 429             for File in MiscFile.GetFileList():
 430                 NodeList.append\
 431                 (CreateXmlElement\
 432                  ('Filename', File.GetURI(), [], \
 433                   [['Executable', str(File.GetExecutable()).lower()]]))
 434             Root = CreateXmlElement('%s' % Key, '', NodeList, [])
 435
 436             return Root
 437     ##
 438     # This API is used for DistP's tool section
 439     #
 440     def ToXml2(self, MiscFile, Key):
 441         if self.Header:
 442             pass
 443         if MiscFile:
 444             NodeList = [['Name', MiscFile.GetName()],
 445                         ['Copyright', MiscFile.GetCopyright()],
 446                         ['License', MiscFile.GetLicense()],
 447                         ['Abstract', MiscFile.GetAbstract()],
 448                         ['Description', MiscFile.GetDescription()],
 449                        ]
 450             HeaderNode = CreateXmlElement('Header', '', NodeList, [])
 451             NodeList = [HeaderNode]
 452
 453             for File in MiscFile.GetFileList():
 454                 NodeList.append\
 455                 (CreateXmlElement\
 456                  ('Filename', File.GetURI(), [], \
 457                   [['Executable', str(File.GetExecutable()).lower()], \
 458                    ['OS', File.GetOS()]]))
 459             Root = CreateXmlElement('%s' % Key, '', NodeList, [])
 460
 461             return Root
 462
 463     def __str__(self):
 464         Str = str(self.Header)
 465         for Item in self.Files:
 466             Str = Str + '\n\tFilename:' + str(Item)
 467         return Str
 468 ##
 469 # UserExtensionsXml
 470 #
 471 class UserExtensionsXml(object):
 472     def __init__(self):
 473         self.UserId = ''
 474         self.Identifier = ''
 475         self.DefineDict = {}
 476         self.BuildOptionDict = {}
 477         self.IncludesDict = {}
 478         self.SourcesDict = {}
 479         self.BinariesDict = {}
 480         self.SupArchList = []
 481         self.Statement = ''
 482         self.Defines = ''
 483         self.BuildOptions = ''
 484
 485     def FromXml2(self, Item, Key):
 486         self.UserId = XmlAttribute(XmlNode(Item, '%s' % Key), 'UserId')
 487         self.Identifier = XmlAttribute(XmlNode(Item, '%s' % Key), 'Identifier')
 488
 489         UserExtension = UserExtensionObject()
 490         UserExtension.SetUserID(self.UserId)
 491         UserExtension.SetIdentifier(self.Identifier)
 492
 493         return UserExtension
 494
 495     def FromXml(self, Item, Key):
 496         self.UserId = XmlAttribute(XmlNode(Item, '%s' % Key), 'UserId')
 497         self.Identifier = XmlAttribute(XmlNode(Item, '%s' % Key), 'Identifier')
 498
 499         DefineItem = XmlNode(Item, '%s/Define' % Key)
 500         for SubItem in XmlList(DefineItem, 'Define/Statement'):
 501             Statement = XmlElement(SubItem, '%s/Statement' % Key)
 502             self.DefineDict[Statement] = ""
 503
 504         BuildOptionItem = XmlNode(Item, '%s/BuildOption' % Key)
 505         for SubItem in XmlList(BuildOptionItem, 'BuildOption/Statement'):
 506             Statement = XmlElement(SubItem, '%s/Statement' % Key)
 507             Arch = XmlAttribute(XmlNode(SubItem, '%s/Statement' % Key), 'SupArchList')
 508             self.BuildOptionDict[Arch] = Statement
 509
 510         IncludesItem = XmlNode(Item, '%s/Includes' % Key)
 511         for SubItem in XmlList(IncludesItem, 'Includes/Statement'):
 512             Statement = XmlElement(SubItem, '%s/Statement' % Key)
 513             Arch = XmlAttribute(XmlNode(SubItem, '%s/Statement' % Key), 'SupArchList')
 514             self.IncludesDict[Statement] = Arch
 515
 516         SourcesItem = XmlNode(Item, '%s/Sources' % Key)
 517         Tmp = UserExtensionSourceXml()
 518         SourceDict = Tmp.FromXml(SourcesItem, 'Sources')
 519         self.SourcesDict = SourceDict
 520
 521         BinariesItem = XmlNode(Item, '%s/Binaries' % Key)
 522         Tmp = UserExtensionBinaryXml()
 523         BinariesDict = Tmp.FromXml(BinariesItem, 'Binaries')
 524         self.BinariesDict = BinariesDict
 525
 526         self.Statement = XmlElement(Item, 'UserExtensions')
 527         SupArch = XmlAttribute(XmlNode(Item, '%s' % Key), 'SupArchList')
 528         self.SupArchList = [Arch for Arch in GetSplitValueList(SupArch, DataType.TAB_SPACE_SPLIT) if Arch]
 529
 530         UserExtension = UserExtensionObject()
 531         UserExtension.SetUserID(self.UserId)
 532         UserExtension.SetIdentifier(self.Identifier)
 533         UserExtension.SetStatement(self.Statement)
 534         UserExtension.SetSupArchList(self.SupArchList)
 535         UserExtension.SetDefinesDict(self.DefineDict)
 536         UserExtension.SetBuildOptionDict(self.BuildOptionDict)
 537         UserExtension.SetIncludesDict(self.IncludesDict)
 538         UserExtension.SetSourcesDict(self.SourcesDict)
 539         UserExtension.SetBinariesDict(self.BinariesDict)
 540
 541         return UserExtension
 542
 543     def ToXml(self, UserExtension, Key):
 544         if self.UserId:
 545             pass
 546
 547         AttributeList = [['UserId', str(UserExtension.GetUserID())],
 548                          ['Identifier', str(UserExtension.GetIdentifier())],
 549                          ['SupArchList', \
 550                           GetStringOfList(UserExtension.GetSupArchList())],
 551                         ]
 552
 553         Root = CreateXmlElement('%s' % Key, UserExtension.GetStatement(), [], \
 554                                 AttributeList)
 555
 556         NodeList = []
 557         DefineDict = UserExtension.GetDefinesDict()
 558         if DefineDict:
 559             for Item in DefineDict.keys():
 560                 NodeList.append(CreateXmlElement\
 561                                 ('Statement', Item, [], []))
 562             DefineElement = CreateXmlElement('Define', '', NodeList, [])
 563             Root.appendChild(DefineElement)
 564
 565         NodeList = []
 566         BuildOptionDict = UserExtension.GetBuildOptionDict()
 567         if BuildOptionDict:
 568             for Item in BuildOptionDict.keys():
 569                 NodeList.append(CreateXmlElement\
 570                                 ('Statement', BuildOptionDict[Item], [], \
 571                                  [['SupArchList', Item]]))
 572             BuildOptionElement = \
 573             CreateXmlElement('BuildOption', '', NodeList, [])
 574             Root.appendChild(BuildOptionElement)
 575
 576         NodeList = []
 577         IncludesDict = UserExtension.GetIncludesDict()
 578         if IncludesDict:
 579             for Item in IncludesDict.keys():
 580                 NodeList.append(CreateXmlElement\
 581                                 ('Statement', Item, [], \
 582                                  [['SupArchList', IncludesDict[Item]]]))
 583             IncludesElement = CreateXmlElement('Includes', '', NodeList, [])
 584             Root.appendChild(IncludesElement)
 585
 586         NodeList = []
 587         SourcesDict = UserExtension.GetSourcesDict()
 588         if SourcesDict:
 589             Tmp = UserExtensionSourceXml()
 590             Root.appendChild(Tmp.ToXml(SourcesDict, 'Sources'))
 591
 592         NodeList = []
 593         BinariesDict = UserExtension.GetBinariesDict()
 594         if BinariesDict:
 595             Tmp = UserExtensionBinaryXml()
 596             Root.appendChild(Tmp.ToXml(BinariesDict, 'Binaries'))
 597
 598         return Root
 599
 600     def __str__(self):
 601         Str = "UserId = %s Identifier = %s" % (self.UserId, self.Identifier)
 602         Str = Str + '\n\tDefines:' + str(self.Defines)
 603         Str = Str + '\n\tBuildOptions:' + str(self.BuildOptions)
 604         return Str
 605
 606 ##
 607 # UserExtensionSourceXml
 608 #
 609 class UserExtensionSourceXml(object):
 610     def __init__(self):
 611         self.UserExtensionSource = ''
 612
 613     def FromXml(self, Item, Key):
 614         if Key:
 615             pass
 616         if self.UserExtensionSource:
 617             pass
 618         Dict = {}
 619
 620         #SourcesItem = XmlNode(Item, '%s/Sources' % Key)
 621         for SubItem in XmlList(Item, 'Sources/SourceFile'):
 622             FileName = XmlElement(SubItem, 'SourceFile/FileName')
 623             Family = XmlElement(SubItem, 'SourceFile/Family')
 624             FeatureFlag = XmlElement(SubItem, 'SourceFile/FeatureFlag')
 625             SupArchStr = XmlElement(SubItem, 'SourceFile/SupArchList')
 626             DictKey = (FileName, Family, FeatureFlag, SupArchStr)
 627
 628             ValueList = []
 629             for ValueNodeItem in XmlList(SubItem, \
 630                                          'SourceFile/SourceFileOtherAttr'):
 631                 TagName = XmlElement(ValueNodeItem, \
 632                                      'SourceFileOtherAttr/TagName')
 633                 ToolCode = XmlElement(ValueNodeItem, \
 634                                       'SourceFileOtherAttr/ToolCode')
 635                 Comment = XmlElement(ValueNodeItem, \
 636                                      'SourceFileOtherAttr/Comment')
 637                 if (TagName == ' ') and (ToolCode == ' ') and (Comment == ' '):
 638                     TagName = ''
 639                     ToolCode = ''
 640                     Comment = ''
 641                 ValueList.append((TagName, ToolCode, Comment))
 642
 643             Dict[DictKey] = ValueList
 644
 645         return Dict
 646
 647     def ToXml(self, Dict, Key):
 648         if self.UserExtensionSource:
 649             pass
 650         SourcesNodeList = []
 651         for Item in Dict:
 652             ValueList = Dict[Item]
 653             (FileName, Family, FeatureFlag, SupArchStr) = Item
 654             SourceFileNodeList = []
 655             SourceFileNodeList.append(["FileName", FileName])
 656             SourceFileNodeList.append(["Family", Family])
 657             SourceFileNodeList.append(["FeatureFlag", FeatureFlag])
 658             SourceFileNodeList.append(["SupArchList", SupArchStr])
 659             for (TagName, ToolCode, Comment) in ValueList:
 660                 ValueNodeList = []
 661                 if not (TagName or ToolCode or Comment):
 662                     TagName = ' '
 663                     ToolCode = ' '
 664                     Comment = ' '
 665                 ValueNodeList.append(["TagName", TagName])
 666                 ValueNodeList.append(["ToolCode", ToolCode])
 667                 ValueNodeList.append(["Comment", Comment])
 668                 ValueNodeXml = CreateXmlElement('SourceFileOtherAttr', '', \
 669                                                 ValueNodeList, [])
 670                 SourceFileNodeList.append(ValueNodeXml)
 671             SourceFileNodeXml = CreateXmlElement('SourceFile', '', \
 672                                                  SourceFileNodeList, [])
 673             SourcesNodeList.append(SourceFileNodeXml)
 674         Root = CreateXmlElement('%s' % Key, '', SourcesNodeList, [])
 675         return Root
 676
 677 ##
 678 # UserExtensionBinaryXml
 679 #
 680 class UserExtensionBinaryXml(object):
 681     def __init__(self):
 682         self.UserExtensionBinary = ''
 683
 684     def FromXml(self, Item, Key):
 685         if Key:
 686             pass
 687         if self.UserExtensionBinary:
 688             pass
 689
 690         Dict = {}
 691
 692         for SubItem in XmlList(Item, 'Binaries/Binary'):
 693             FileName = XmlElement(SubItem, 'Binary/FileName')
 694             FileType = XmlElement(SubItem, 'Binary/FileType')
 695             FFE = XmlElement(SubItem, 'Binary/FeatureFlag')
 696             SupArch = XmlElement(SubItem, 'Binary/SupArchList')
 697             DictKey = (FileName, FileType, ConvertNOTEQToNE(FFE), SupArch)
 698
 699             ValueList = []
 700             for ValueNodeItem in XmlList(SubItem, \
 701                                          'Binary/BinaryFileOtherAttr'):
 702                 Target = XmlElement(ValueNodeItem, \
 703                                     'BinaryFileOtherAttr/Target')
 704                 Family = XmlElement(ValueNodeItem, \
 705                                     'BinaryFileOtherAttr/Family')
 706                 TagName = XmlElement(ValueNodeItem, \
 707                                      'BinaryFileOtherAttr/TagName')
 708                 Comment = XmlElement(ValueNodeItem, \
 709                                      'BinaryFileOtherAttr/Comment')
 710                 if (Target == ' ') and (Family == ' ') and \
 711                    (TagName == ' ') and (Comment == ' '):
 712                     Target = ''
 713                     Family = ''
 714                     TagName = ''
 715                     Comment = ''
 716
 717                 ValueList.append((Target, Family, TagName, Comment))
 718
 719             Dict[DictKey] = ValueList
 720
 721         return Dict
 722
 723     def ToXml(self, Dict, Key):
 724         if self.UserExtensionBinary:
 725             pass
 726         BinariesNodeList = []
 727         for Item in Dict:
 728             ValueList = Dict[Item]
 729             (FileName, FileType, FeatureFlag, SupArch) = Item
 730             FileNodeList = []
 731             FileNodeList.append(["FileName", FileName])
 732             FileNodeList.append(["FileType", FileType])
 733             FileNodeList.append(["FeatureFlag", ConvertNEToNOTEQ(FeatureFlag)])
 734             FileNodeList.append(["SupArchList", SupArch])
 735             for (Target, Family, TagName, Comment) in ValueList:
 736                 ValueNodeList = []
 737                 if not (Target or Family or TagName or Comment):
 738                     Target = ' '
 739                     Family = ' '
 740                     TagName = ' '
 741                     Comment = ' '
 742                 ValueNodeList.append(["Target", Target])
 743                 ValueNodeList.append(["Family", Family])
 744                 ValueNodeList.append(["TagName", TagName])
 745                 ValueNodeList.append(["Comment", Comment])
 746                 ValueNodeXml = CreateXmlElement('BinaryFileOtherAttr', '', \
 747                                                 ValueNodeList, [])
 748                 FileNodeList.append(ValueNodeXml)
 749             FileNodeXml = CreateXmlElement('Binary', '', FileNodeList, [])
 750             BinariesNodeList.append(FileNodeXml)
 751         Root = CreateXmlElement('%s' % Key, '', BinariesNodeList, [])
 752         return Root
 753
 754 ##
 755 # LibraryClassXml
 756 #
 757 class LibraryClassXml(object):
 758     def __init__(self):
 759         self.Keyword = ''
 760         self.HeaderFile = ''
 761         self.RecommendedInstanceGuid = ''
 762         self.RecommendedInstanceVersion = ''
 763         self.CommonDefines = CommonDefinesXml()
 764         self.HelpText = []
 765
 766     def FromXml(self, Item, Key):
 767         self.Keyword = XmlAttribute(XmlNode(Item, '%s' % Key), 'Keyword')
 768         if self.Keyword == '':
 769             self.Keyword = XmlElement(Item, '%s/Keyword' % Key)
 770         self.HeaderFile = XmlElement(Item, '%s/HeaderFile' % Key)
 771         self.CommonDefines.FromXml(XmlNode(Item, '%s' % Key), Key)
 772         for HelpTextItem in XmlList(Item, '%s/HelpText' % Key):
 773             HelpTextObj = HelpTextXml()
 774             HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)
 775             self.HelpText.append(HelpTextObj)
 776
 777         LibraryClass = LibraryClassObject()
 778         LibraryClass.SetLibraryClass(self.Keyword)
 779         LibraryClass.SetIncludeHeader(self.HeaderFile)
 780         if self.CommonDefines.Usage:
 781             LibraryClass.SetUsage(self.CommonDefines.Usage)
 782         LibraryClass.SetSupArchList(self.CommonDefines.SupArchList)
 783         LibraryClass.SetSupModuleList(self.CommonDefines.SupModList)
 784         LibraryClass.SetFeatureFlag(ConvertNOTEQToNE(self.CommonDefines.FeatureFlag))
 785         LibraryClass.SetHelpTextList(GetHelpTextList(self.HelpText))
 786
 787         return LibraryClass
 788
 789     def ToXml(self, LibraryClass, Key):
 790         if self.HeaderFile:
 791             pass
 792         AttributeList = \
 793         [['Keyword', LibraryClass.GetLibraryClass()],
 794          ['SupArchList', GetStringOfList(LibraryClass.GetSupArchList())],
 795          ['SupModList', GetStringOfList(LibraryClass.GetSupModuleList())]
 796          ]
 797         NodeList = [['HeaderFile', LibraryClass.GetIncludeHeader()]]
 798         for Item in LibraryClass.GetHelpTextList():
 799             Tmp = HelpTextXml()
 800             NodeList.append(Tmp.ToXml(Item))
 801
 802         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
 803
 804         return Root
 805
 806     def ToXml2(self, LibraryClass, Key):
 807         if self.HeaderFile:
 808             pass
 809
 810         FeatureFlag = ConvertNEToNOTEQ(LibraryClass.GetFeatureFlag())
 811
 812         AttributeList = \
 813         [['Usage', LibraryClass.GetUsage()], \
 814          ['SupArchList', GetStringOfList(LibraryClass.GetSupArchList())], \
 815          ['SupModList', GetStringOfList(LibraryClass.GetSupModuleList())], \
 816          ['FeatureFlag', FeatureFlag]
 817          ]
 818         NodeList = [['Keyword', LibraryClass.GetLibraryClass()], ]
 819         for Item in LibraryClass.GetHelpTextList():
 820             Tmp = HelpTextXml()
 821             NodeList.append(Tmp.ToXml(Item))
 822
 823         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
 824
 825         return Root
 826
 827     def __str__(self):
 828         Str = "Keyword = %s HeaderFile = %s RecommendedInstanceGuid = %s RecommendedInstanceVersion = %s %s" % \
 829               (self.Keyword, self.HeaderFile, self.RecommendedInstanceGuid, self.RecommendedInstanceVersion, \
 830               self.CommonDefines)
 831         for Item in self.HelpText:
 832             Str = Str + "\n\t" + str(Item)
 833         return Str
 834
 835 ##
 836 # FilenameXml
 837 #
 838 class FilenameXml(object):
 839     def __init__(self):
 840         self.FileType = ''
 841         self.Filename = ''
 842         self.CommonDefines = CommonDefinesXml()
 843
 844     def FromXml(self, Item, Key):
 845         self.FileType = XmlAttribute(Item, 'FileType')
 846         self.Filename = XmlElement(Item, 'Filename')
 847         self.CommonDefines.FromXml(Item, Key)
 848
 849         FeatureFlag = ConvertNOTEQToNE(self.CommonDefines.FeatureFlag)
 850
 851         Filename = FileNameObject()
 852         #
 853         # Convert File Type
 854         #
 855         if self.FileType == 'UEFI_IMAGE':
 856             self.FileType = 'PE32'
 857
 858         Filename.SetFileType(self.FileType)
 859         Filename.SetFilename(self.Filename)
 860         Filename.SetSupArchList(self.CommonDefines.SupArchList)
 861         Filename.SetFeatureFlag(FeatureFlag)
 862
 863         return Filename
 864
 865     def ToXml(self, Filename, Key):
 866         if self.Filename:
 867             pass
 868         AttributeList = [['SupArchList', \
 869                           GetStringOfList(Filename.GetSupArchList())],
 870                          ['FileType', Filename.GetFileType()],
 871                          ['FeatureFlag', ConvertNEToNOTEQ(Filename.GetFeatureFlag())],
 872                         ]
 873         Root = CreateXmlElement('%s' % Key, Filename.GetFilename(), [], AttributeList)
 874
 875         return Root
 876
 877     def __str__(self):
 878         return "FileType = %s Filename = %s %s" \
 879              % (self.FileType, self.Filename, self.CommonDefines)