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 - 2013, 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             elif Executable.upper() == "FALSE":
 361                 Executable = False
 362             else:
 363                 Executable = ''
 364             self.Files.append([Filename, Executable])
 365
 366         MiscFile = MiscFileObject()
 367         MiscFile.SetCopyright(self.Header.Copyright)
 368         MiscFile.SetLicense(self.Header.License)
 369         MiscFile.SetAbstract(self.Header.Abstract)
 370         MiscFile.SetDescription(self.Header.Description)
 371         MiscFileList = []
 372         for File in self.Files:
 373             FileObj = FileObject()
 374             FileObj.SetURI(File[0])
 375             FileObj.SetExecutable(File[1])
 376             MiscFileList.append(FileObj)
 377         MiscFile.SetFileList(MiscFileList)
 378
 379         return MiscFile
 380     ##
 381     # This API is used for DistP's tool section
 382     #
 383     def FromXml2(self, Item, Key):
 384         if Item is None:
 385             return None
 386
 387         NewItem = XmlNode(Item, '%s/Header' % Key)
 388         self.Header.FromXml(NewItem, 'Header')
 389
 390         for SubItem in XmlList(Item, '%s/Filename' % Key):
 391             Filename = XmlElement(SubItem, '%s/Filename' % Key)
 392             Executable = \
 393             XmlAttribute(XmlNode(SubItem, '%s/Filename' % Key), 'Executable')
 394             OsType = XmlAttribute(XmlNode(SubItem, '%s/Filename' % Key), 'OS')
 395             if Executable.upper() == "TRUE":
 396                 Executable = True
 397             elif Executable.upper() == "FALSE":
 398                 Executable = False
 399             else:
 400                 Executable = ''
 401             self.Files.append([Filename, Executable, OsType])
 402
 403         MiscFile = MiscFileObject()
 404         MiscFile.SetName(self.Header.Name)
 405         MiscFile.SetCopyright(self.Header.Copyright)
 406         MiscFile.SetLicense(self.Header.License)
 407         MiscFile.SetAbstract(self.Header.Abstract)
 408         MiscFile.SetDescription(self.Header.Description)
 409         MiscFileList = []
 410         for File in self.Files:
 411             FileObj = FileObject()
 412             FileObj.SetURI(File[0])
 413             FileObj.SetExecutable(File[1])
 414             FileObj.SetOS(File[2])
 415             MiscFileList.append(FileObj)
 416         MiscFile.SetFileList(MiscFileList)
 417
 418         return MiscFile
 419
 420     ##
 421     # This API is used for Package or Module's MiscellaneousFile section
 422     #
 423     def ToXml(self, MiscFile, Key):
 424         if self.Header:
 425             pass
 426         if MiscFile:
 427             NodeList = [['Copyright', MiscFile.GetCopyright()],
 428                         ['License', MiscFile.GetLicense()],
 429                         ['Abstract', MiscFile.GetAbstract()],
 430                         ['Description', MiscFile.GetDescription()],
 431                        ]
 432
 433             for File in MiscFile.GetFileList():
 434                 NodeList.append\
 435                 (CreateXmlElement\
 436                  ('Filename', File.GetURI(), [], \
 437                   [['Executable', str(File.GetExecutable()).lower()]]))
 438             Root = CreateXmlElement('%s' % Key, '', NodeList, [])
 439
 440             return Root
 441     ##
 442     # This API is used for DistP's tool section
 443     #
 444     def ToXml2(self, MiscFile, Key):
 445         if self.Header:
 446             pass
 447         if MiscFile:
 448             NodeList = [['Name', MiscFile.GetName()],
 449                         ['Copyright', MiscFile.GetCopyright()],
 450                         ['License', MiscFile.GetLicense()],
 451                         ['Abstract', MiscFile.GetAbstract()],
 452                         ['Description', MiscFile.GetDescription()],
 453                        ]
 454             HeaderNode = CreateXmlElement('Header', '', NodeList, [])
 455             NodeList = [HeaderNode]
 456
 457             for File in MiscFile.GetFileList():
 458                 NodeList.append\
 459                 (CreateXmlElement\
 460                  ('Filename', File.GetURI(), [], \
 461                   [['Executable', str(File.GetExecutable()).lower()], \
 462                    ['OS', File.GetOS()]]))
 463             Root = CreateXmlElement('%s' % Key, '', NodeList, [])
 464
 465             return Root
 466
 467     def __str__(self):
 468         Str = str(self.Header)
 469         for Item in self.Files:
 470             Str = Str + '\n\tFilename:' + str(Item)
 471         return Str
 472 ##
 473 # UserExtensionsXml
 474 #
 475 class UserExtensionsXml(object):
 476     def __init__(self):
 477         self.UserId = ''
 478         self.Identifier = ''
 479         self.DefineDict = {}
 480         self.BuildOptionDict = {}
 481         self.IncludesDict = {}
 482         self.SourcesDict = {}
 483         self.BinariesDict = {}
 484         self.SupArchList = []
 485         self.Statement = ''
 486         self.Defines = ''
 487         self.BuildOptions = ''
 488
 489     def FromXml2(self, Item, Key):
 490         self.UserId = XmlAttribute(XmlNode(Item, '%s' % Key), 'UserId')
 491         self.Identifier = XmlAttribute(XmlNode(Item, '%s' % Key), 'Identifier')
 492
 493         UserExtension = UserExtensionObject()
 494         UserExtension.SetUserID(self.UserId)
 495         UserExtension.SetIdentifier(self.Identifier)
 496
 497         return UserExtension
 498
 499     def FromXml(self, Item, Key):
 500         self.UserId = XmlAttribute(XmlNode(Item, '%s' % Key), 'UserId')
 501         self.Identifier = XmlAttribute(XmlNode(Item, '%s' % Key), 'Identifier')
 502
 503         DefineItem = XmlNode(Item, '%s/Define' % Key)
 504         for SubItem in XmlList(DefineItem, 'Define/Statement'):
 505             Statement = XmlElement(SubItem, '%s/Statement' % Key)
 506             self.DefineDict[Statement] = ""
 507
 508         BuildOptionItem = XmlNode(Item, '%s/BuildOption' % Key)
 509         for SubItem in XmlList(BuildOptionItem, 'BuildOption/Statement'):
 510             Statement = XmlElement(SubItem, '%s/Statement' % Key)
 511             Arch = XmlAttribute(XmlNode(SubItem, '%s/Statement' % Key), 'SupArchList')
 512             self.BuildOptionDict[Arch] = Statement
 513
 514         IncludesItem = XmlNode(Item, '%s/Includes' % Key)
 515         for SubItem in XmlList(IncludesItem, 'Includes/Statement'):
 516             Statement = XmlElement(SubItem, '%s/Statement' % Key)
 517             Arch = XmlAttribute(XmlNode(SubItem, '%s/Statement' % Key), 'SupArchList')
 518             self.IncludesDict[Statement] = Arch
 519
 520         SourcesItem = XmlNode(Item, '%s/Sources' % Key)
 521         Tmp = UserExtensionSourceXml()
 522         SourceDict = Tmp.FromXml(SourcesItem, 'Sources')
 523         self.SourcesDict = SourceDict
 524
 525         BinariesItem = XmlNode(Item, '%s/Binaries' % Key)
 526         Tmp = UserExtensionBinaryXml()
 527         BinariesDict = Tmp.FromXml(BinariesItem, 'Binaries')
 528         self.BinariesDict = BinariesDict
 529
 530         self.Statement = XmlElement(Item, 'UserExtensions')
 531         SupArch = XmlAttribute(XmlNode(Item, '%s' % Key), 'SupArchList')
 532         self.SupArchList = [Arch for Arch in GetSplitValueList(SupArch, DataType.TAB_SPACE_SPLIT) if Arch]
 533
 534         UserExtension = UserExtensionObject()
 535         UserExtension.SetUserID(self.UserId)
 536         UserExtension.SetIdentifier(self.Identifier)
 537         UserExtension.SetStatement(self.Statement)
 538         UserExtension.SetSupArchList(self.SupArchList)
 539         UserExtension.SetDefinesDict(self.DefineDict)
 540         UserExtension.SetBuildOptionDict(self.BuildOptionDict)
 541         UserExtension.SetIncludesDict(self.IncludesDict)
 542         UserExtension.SetSourcesDict(self.SourcesDict)
 543         UserExtension.SetBinariesDict(self.BinariesDict)
 544
 545         return UserExtension
 546
 547     def ToXml(self, UserExtension, Key):
 548         if self.UserId:
 549             pass
 550
 551         AttributeList = [['UserId', str(UserExtension.GetUserID())],
 552                          ['Identifier', str(UserExtension.GetIdentifier())],
 553                          ['SupArchList', \
 554                           GetStringOfList(UserExtension.GetSupArchList())],
 555                         ]
 556
 557         Root = CreateXmlElement('%s' % Key, UserExtension.GetStatement(), [], \
 558                                 AttributeList)
 559
 560         NodeList = []
 561         DefineDict = UserExtension.GetDefinesDict()
 562         if DefineDict:
 563             for Item in DefineDict.keys():
 564                 NodeList.append(CreateXmlElement\
 565                                 ('Statement', Item, [], []))
 566             DefineElement = CreateXmlElement('Define', '', NodeList, [])
 567             Root.appendChild(DefineElement)
 568
 569         NodeList = []
 570         BuildOptionDict = UserExtension.GetBuildOptionDict()
 571         if BuildOptionDict:
 572             for Item in BuildOptionDict.keys():
 573                 NodeList.append(CreateXmlElement\
 574                                 ('Statement', BuildOptionDict[Item], [], \
 575                                  [['SupArchList', Item]]))
 576             BuildOptionElement = \
 577             CreateXmlElement('BuildOption', '', NodeList, [])
 578             Root.appendChild(BuildOptionElement)
 579
 580         NodeList = []
 581         IncludesDict = UserExtension.GetIncludesDict()
 582         if IncludesDict:
 583             for Item in IncludesDict.keys():
 584                 NodeList.append(CreateXmlElement\
 585                                 ('Statement', Item, [], \
 586                                  [['SupArchList', IncludesDict[Item]]]))
 587             IncludesElement = CreateXmlElement('Includes', '', NodeList, [])
 588             Root.appendChild(IncludesElement)
 589
 590         NodeList = []
 591         SourcesDict = UserExtension.GetSourcesDict()
 592         if SourcesDict:
 593             Tmp = UserExtensionSourceXml()
 594             Root.appendChild(Tmp.ToXml(SourcesDict, 'Sources'))
 595
 596         NodeList = []
 597         BinariesDict = UserExtension.GetBinariesDict()
 598         if BinariesDict:
 599             Tmp = UserExtensionBinaryXml()
 600             Root.appendChild(Tmp.ToXml(BinariesDict, 'Binaries'))
 601
 602         return Root
 603
 604     def __str__(self):
 605         Str = "UserId = %s Identifier = %s" % (self.UserId, self.Identifier)
 606         Str = Str + '\n\tDefines:' + str(self.Defines)
 607         Str = Str + '\n\tBuildOptions:' + str(self.BuildOptions)
 608         return Str
 609
 610 ##
 611 # UserExtensionSourceXml
 612 #
 613 class UserExtensionSourceXml(object):
 614     def __init__(self):
 615         self.UserExtensionSource = ''
 616
 617     def FromXml(self, Item, Key):
 618         if Key:
 619             pass
 620         if self.UserExtensionSource:
 621             pass
 622         Dict = {}
 623
 624         #SourcesItem = XmlNode(Item, '%s/Sources' % Key)
 625         for SubItem in XmlList(Item, 'Sources/SourceFile'):
 626             FileName = XmlElement(SubItem, 'SourceFile/FileName')
 627             Family = XmlElement(SubItem, 'SourceFile/Family')
 628             FeatureFlag = XmlElement(SubItem, 'SourceFile/FeatureFlag')
 629             SupArchStr = XmlElement(SubItem, 'SourceFile/SupArchList')
 630             DictKey = (FileName, Family, FeatureFlag, SupArchStr)
 631
 632             ValueList = []
 633             for ValueNodeItem in XmlList(SubItem, \
 634                                          'SourceFile/SourceFileOtherAttr'):
 635                 TagName = XmlElement(ValueNodeItem, \
 636                                      'SourceFileOtherAttr/TagName')
 637                 ToolCode = XmlElement(ValueNodeItem, \
 638                                       'SourceFileOtherAttr/ToolCode')
 639                 Comment = XmlElement(ValueNodeItem, \
 640                                      'SourceFileOtherAttr/Comment')
 641                 if (TagName == ' ') and (ToolCode == ' ') and (Comment == ' '):
 642                     TagName = ''
 643                     ToolCode = ''
 644                     Comment = ''
 645                 ValueList.append((TagName, ToolCode, Comment))
 646
 647             Dict[DictKey] = ValueList
 648
 649         return Dict
 650
 651     def ToXml(self, Dict, Key):
 652         if self.UserExtensionSource:
 653             pass
 654         SourcesNodeList = []
 655         for Item in Dict:
 656             ValueList = Dict[Item]
 657             (FileName, Family, FeatureFlag, SupArchStr) = Item
 658             SourceFileNodeList = []
 659             SourceFileNodeList.append(["FileName", FileName])
 660             SourceFileNodeList.append(["Family", Family])
 661             SourceFileNodeList.append(["FeatureFlag", FeatureFlag])
 662             SourceFileNodeList.append(["SupArchList", SupArchStr])
 663             for (TagName, ToolCode, Comment) in ValueList:
 664                 ValueNodeList = []
 665                 if not (TagName or ToolCode or Comment):
 666                     TagName = ' '
 667                     ToolCode = ' '
 668                     Comment = ' '
 669                 ValueNodeList.append(["TagName", TagName])
 670                 ValueNodeList.append(["ToolCode", ToolCode])
 671                 ValueNodeList.append(["Comment", Comment])
 672                 ValueNodeXml = CreateXmlElement('SourceFileOtherAttr', '', \
 673                                                 ValueNodeList, [])
 674                 SourceFileNodeList.append(ValueNodeXml)
 675             SourceFileNodeXml = CreateXmlElement('SourceFile', '', \
 676                                                  SourceFileNodeList, [])
 677             SourcesNodeList.append(SourceFileNodeXml)
 678         Root = CreateXmlElement('%s' % Key, '', SourcesNodeList, [])
 679         return Root
 680
 681 ##
 682 # UserExtensionBinaryXml
 683 #
 684 class UserExtensionBinaryXml(object):
 685     def __init__(self):
 686         self.UserExtensionBinary = ''
 687
 688     def FromXml(self, Item, Key):
 689         if Key:
 690             pass
 691         if self.UserExtensionBinary:
 692             pass
 693
 694         Dict = {}
 695
 696         for SubItem in XmlList(Item, 'Binaries/Binary'):
 697             FileName = XmlElement(SubItem, 'Binary/FileName')
 698             FileType = XmlElement(SubItem, 'Binary/FileType')
 699             FFE = XmlElement(SubItem, 'Binary/FeatureFlag')
 700             SupArch = XmlElement(SubItem, 'Binary/SupArchList')
 701             DictKey = (FileName, FileType, ConvertNOTEQToNE(FFE), SupArch)
 702
 703             ValueList = []
 704             for ValueNodeItem in XmlList(SubItem, \
 705                                          'Binary/BinaryFileOtherAttr'):
 706                 Target = XmlElement(ValueNodeItem, \
 707                                     'BinaryFileOtherAttr/Target')
 708                 Family = XmlElement(ValueNodeItem, \
 709                                     'BinaryFileOtherAttr/Family')
 710                 TagName = XmlElement(ValueNodeItem, \
 711                                      'BinaryFileOtherAttr/TagName')
 712                 Comment = XmlElement(ValueNodeItem, \
 713                                      'BinaryFileOtherAttr/Comment')
 714                 if (Target == ' ') and (Family == ' ') and \
 715                    (TagName == ' ') and (Comment == ' '):
 716                     Target = ''
 717                     Family = ''
 718                     TagName = ''
 719                     Comment = ''
 720
 721                 ValueList.append((Target, Family, TagName, Comment))
 722
 723             Dict[DictKey] = ValueList
 724
 725         return Dict
 726
 727     def ToXml(self, Dict, Key):
 728         if self.UserExtensionBinary:
 729             pass
 730         BinariesNodeList = []
 731         for Item in Dict:
 732             ValueList = Dict[Item]
 733             (FileName, FileType, FeatureFlag, SupArch) = Item
 734             FileNodeList = []
 735             FileNodeList.append(["FileName", FileName])
 736             FileNodeList.append(["FileType", FileType])
 737             FileNodeList.append(["FeatureFlag", ConvertNEToNOTEQ(FeatureFlag)])
 738             FileNodeList.append(["SupArchList", SupArch])
 739             for (Target, Family, TagName, Comment) in ValueList:
 740                 ValueNodeList = []
 741                 if not (Target or Family or TagName or Comment):
 742                     Target = ' '
 743                     Family = ' '
 744                     TagName = ' '
 745                     Comment = ' '
 746                 ValueNodeList.append(["Target", Target])
 747                 ValueNodeList.append(["Family", Family])
 748                 ValueNodeList.append(["TagName", TagName])
 749                 ValueNodeList.append(["Comment", Comment])
 750                 ValueNodeXml = CreateXmlElement('BinaryFileOtherAttr', '', \
 751                                                 ValueNodeList, [])
 752                 FileNodeList.append(ValueNodeXml)
 753             FileNodeXml = CreateXmlElement('Binary', '', FileNodeList, [])
 754             BinariesNodeList.append(FileNodeXml)
 755         Root = CreateXmlElement('%s' % Key, '', BinariesNodeList, [])
 756         return Root
 757
 758 ##
 759 # LibraryClassXml
 760 #
 761 class LibraryClassXml(object):
 762     def __init__(self):
 763         self.Keyword = ''
 764         self.HeaderFile = ''
 765         self.RecommendedInstanceGuid = ''
 766         self.RecommendedInstanceVersion = ''
 767         self.CommonDefines = CommonDefinesXml()
 768         self.HelpText = []
 769
 770     def FromXml(self, Item, Key):
 771         self.Keyword = XmlAttribute(XmlNode(Item, '%s' % Key), 'Keyword')
 772         if self.Keyword == '':
 773             self.Keyword = XmlElement(Item, '%s/Keyword' % Key)
 774         self.HeaderFile = XmlElement(Item, '%s/HeaderFile' % Key)
 775         self.CommonDefines.FromXml(XmlNode(Item, '%s' % Key), Key)
 776         for HelpTextItem in XmlList(Item, '%s/HelpText' % Key):
 777             HelpTextObj = HelpTextXml()
 778             HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)
 779             self.HelpText.append(HelpTextObj)
 780
 781         LibraryClass = LibraryClassObject()
 782         LibraryClass.SetLibraryClass(self.Keyword)
 783         LibraryClass.SetIncludeHeader(self.HeaderFile)
 784         if self.CommonDefines.Usage:
 785             LibraryClass.SetUsage(self.CommonDefines.Usage)
 786         LibraryClass.SetSupArchList(self.CommonDefines.SupArchList)
 787         LibraryClass.SetSupModuleList(self.CommonDefines.SupModList)
 788         LibraryClass.SetFeatureFlag(ConvertNOTEQToNE(self.CommonDefines.FeatureFlag))
 789         LibraryClass.SetHelpTextList(GetHelpTextList(self.HelpText))
 790
 791         return LibraryClass
 792
 793     def ToXml(self, LibraryClass, Key):
 794         if self.HeaderFile:
 795             pass
 796         AttributeList = \
 797         [['Keyword', LibraryClass.GetLibraryClass()],
 798          ['SupArchList', GetStringOfList(LibraryClass.GetSupArchList())],
 799          ['SupModList', GetStringOfList(LibraryClass.GetSupModuleList())]
 800          ]
 801         NodeList = [['HeaderFile', LibraryClass.GetIncludeHeader()]]
 802         for Item in LibraryClass.GetHelpTextList():
 803             Tmp = HelpTextXml()
 804             NodeList.append(Tmp.ToXml(Item))
 805
 806         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
 807
 808         return Root
 809
 810     def ToXml2(self, LibraryClass, Key):
 811         if self.HeaderFile:
 812             pass
 813
 814         FeatureFlag = ConvertNEToNOTEQ(LibraryClass.GetFeatureFlag())
 815
 816         AttributeList = \
 817         [['Usage', LibraryClass.GetUsage()], \
 818          ['SupArchList', GetStringOfList(LibraryClass.GetSupArchList())], \
 819          ['SupModList', GetStringOfList(LibraryClass.GetSupModuleList())], \
 820          ['FeatureFlag', FeatureFlag]
 821          ]
 822         NodeList = [['Keyword', LibraryClass.GetLibraryClass()], ]
 823         for Item in LibraryClass.GetHelpTextList():
 824             Tmp = HelpTextXml()
 825             NodeList.append(Tmp.ToXml(Item))
 826
 827         Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
 828
 829         return Root
 830
 831     def __str__(self):
 832         Str = "Keyword = %s HeaderFile = %s RecommendedInstanceGuid = %s RecommendedInstanceVersion = %s %s" % \
 833               (self.Keyword, self.HeaderFile, self.RecommendedInstanceGuid, self.RecommendedInstanceVersion, \
 834               self.CommonDefines)
 835         for Item in self.HelpText:
 836             Str = Str + "\n\t" + str(Item)
 837         return Str
 838
 839 ##
 840 # FilenameXml
 841 #
 842 class FilenameXml(object):
 843     def __init__(self):
 844         self.FileType = ''
 845         self.Filename = ''
 846         self.CommonDefines = CommonDefinesXml()
 847
 848     def FromXml(self, Item, Key):
 849         self.FileType = XmlAttribute(Item, 'FileType')
 850         self.Filename = XmlElement(Item, 'Filename')
 851         self.CommonDefines.FromXml(Item, Key)
 852
 853         FeatureFlag = ConvertNOTEQToNE(self.CommonDefines.FeatureFlag)
 854
 855         Filename = FileNameObject()
 856         #
 857         # Convert File Type
 858         #
 859         if self.FileType == 'UEFI_IMAGE':
 860             self.FileType = 'PE32'
 861
 862         Filename.SetFileType(self.FileType)
 863         Filename.SetFilename(self.Filename)
 864         Filename.SetSupArchList(self.CommonDefines.SupArchList)
 865         Filename.SetFeatureFlag(FeatureFlag)
 866
 867         return Filename
 868
 869     def ToXml(self, Filename, Key):
 870         if self.Filename:
 871             pass
 872         AttributeList = [['SupArchList', \
 873                           GetStringOfList(Filename.GetSupArchList())],
 874                          ['FileType', Filename.GetFileType()],
 875                          ['FeatureFlag', ConvertNEToNOTEQ(Filename.GetFeatureFlag())],
 876                         ]
 877         Root = CreateXmlElement('%s' % Key, Filename.GetFilename(), [], AttributeList)
 878
 879         return Root
 880
 881     def __str__(self):
 882         return "FileType = %s Filename = %s %s" \
 883              % (self.FileType, self.Filename, self.CommonDefines)