2 # This file is used to parse a PCD file of .PKG file
4 # Copyright (c) 2011 - 2013, Intel Corporation. All rights reserved.<BR>
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
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.
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
44 import Library
.DataType
as DataType
49 class ClonedFromXml(object):
54 def FromXml(self
, Item
, Key
):
55 self
.GUID
= XmlElement(Item
, '%s/GUID' % Key
)
56 self
.Version
= XmlAttribute(XmlNode(Item
, '%s/GUID' % Key
), 'Version')
58 if self
.GUID
== '' and self
.Version
== '':
61 ClonedFrom
= ClonedRecordObject()
62 ClonedFrom
.SetPackageGuid(self
.GUID
)
63 ClonedFrom
.SetPackageVersion(self
.Version
)
67 def ToXml(self
, ClonedFrom
, Key
):
70 Element1
= CreateXmlElement('GUID', ClonedFrom
.GetPackageGuid(), [],
71 [['Version', ClonedFrom
.GetPackageVersion()]])
74 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, AttributeList
)
79 return "GUID = %s Version = %s" % (self
.GUID
, self
.Version
)
85 class CommonDefinesXml(object):
92 def FromXml(self
, Item
, Key
):
95 self
.Usage
= XmlAttribute(Item
, 'Usage')
97 [Arch
for Arch
in GetSplitValueList(XmlAttribute(Item
, 'SupArchList'), DataType
.TAB_SPACE_SPLIT
) if Arch
]
99 [Mod
for Mod
in GetSplitValueList(XmlAttribute(Item
, 'SupModList'), DataType
.TAB_SPACE_SPLIT
) if Mod
]
100 self
.FeatureFlag
= ConvertNOTEQToNE(XmlAttribute(Item
, 'FeatureFlag'))
107 return "Usage = %s SupArchList = %s SupModList = %s FeatureFlag = %s" \
108 % (self
.Usage
, self
.SupArchList
, self
.SupModList
, self
.FeatureFlag
)
114 class HelpTextXml(object):
119 def FromXml(self
, Item
, Key
):
122 self
.HelpText
= XmlElement2(Item
, 'HelpText')
123 self
.Lang
= XmlAttribute(Item
, 'Lang')
125 def ToXml(self
, HelpText
, Key
='HelpText'):
128 return CreateXmlElement('%s' % Key
, HelpText
.GetString(), [], [['Lang', HelpText
.GetLang()]])
130 return "HelpText = %s Lang = %s" % (self
.HelpText
, self
.Lang
)
135 class HeaderXml(object):
144 self
.Description
= ''
146 def FromXml(self
, Item
, Key
, IsRequiredCheck
=False, IsStandAlongModule
=False):
147 if not Item
and IsRequiredCheck
:
149 if IsStandAlongModule
:
150 XmlTreeLevel
= ['DistributionPackage', 'ModuleSurfaceArea']
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
)
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
)
176 def ToXml(self
, Header
, Key
):
179 Element1
= CreateXmlElement('Name', Header
.GetName(), [], [['BaseName', Header
.GetBaseName()]])
180 Element2
= CreateXmlElement('GUID', Header
.GetGuid(), [], [['Version', Header
.GetVersion()]])
182 NodeList
= [Element1
,
184 ['Copyright', Header
.GetCopyright()],
185 ['License', Header
.GetLicense()],
186 ['Abstract', Header
.GetAbstract()],
187 ['Description', Header
.GetDescription()],
189 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, AttributeList
)
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
)
199 # DistributionPackageHeaderXml
201 class DistributionPackageHeaderXml(object):
203 self
.Header
= HeaderXml()
209 self
.XmlSpecification
= ''
211 def FromXml(self
, Item
, Key
):
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
)
222 DistributionPackageHeader
= DistributionPackageHeaderObject()
223 if self
.ReadOnly
.upper() == 'TRUE':
224 DistributionPackageHeader
.ReadOnly
= True
225 elif self
.ReadOnly
.upper() == 'FALSE':
226 DistributionPackageHeader
.ReadOnly
= False
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
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
)
246 return DistributionPackageHeader
248 def ToXml(self
, DistributionPackageHeader
, Key
):
251 Element1
= CreateXmlElement('Name', \
252 DistributionPackageHeader
.GetName(), [], \
254 DistributionPackageHeader
.GetBaseName()]])
255 Element2
= CreateXmlElement('GUID', \
256 DistributionPackageHeader
.GetGuid(), [], \
258 DistributionPackageHeader
.GetVersion()]])
260 if DistributionPackageHeader
.ReadOnly
!= '':
261 AttributeList
.append(['ReadOnly', str(DistributionPackageHeader
.ReadOnly
).lower()])
262 if DistributionPackageHeader
.RePackage
!= '':
263 AttributeList
.append(['RePackage', str(DistributionPackageHeader
.RePackage
).lower()])
265 NodeList
= [Element1
,
267 ['Vendor', DistributionPackageHeader
.Vendor
],
268 ['Date', DistributionPackageHeader
.Date
],
269 ['Copyright', DistributionPackageHeader
.GetCopyright()],
270 ['License', DistributionPackageHeader
.GetLicense()],
271 ['Abstract', DistributionPackageHeader
.GetAbstract()],
273 DistributionPackageHeader
.GetDescription()],
274 ['Signature', DistributionPackageHeader
.Signature
],
275 ['XmlSpecification', \
276 DistributionPackageHeader
.XmlSpecification
],
278 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, AttributeList
)
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
)
290 class PackageHeaderXml(object):
292 self
.Header
= HeaderXml()
293 self
.PackagePath
= ''
295 def FromXml(self
, Item
, Key
, PackageObject2
):
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
)
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
)
313 def ToXml(self
, PackageObject2
, Key
):
317 CreateXmlElement('Name', PackageObject2
.GetName(), [], \
318 [['BaseName', PackageObject2
.GetBaseName()]])
319 Element2
= CreateXmlElement('GUID', PackageObject2
.GetGuid(), [], \
320 [['Version', PackageObject2
.GetVersion()]])
322 NodeList
= [Element1
,
324 ['Copyright', PackageObject2
.GetCopyright()],
325 ['License', PackageObject2
.GetLicense()],
326 ['Abstract', PackageObject2
.GetAbstract()],
327 ['Description', PackageObject2
.GetDescription()],
328 ['PackagePath', PackageObject2
.GetPackagePath()],
330 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, AttributeList
)
335 return "PackagePath = %s %s" \
336 % (self
.PackagePath
, self
.Header
)
339 # MiscellaneousFileXml
341 class MiscellaneousFileXml(object):
343 self
.Header
= HeaderXml()
346 # This API is used for Package or Module's MiscellaneousFile section
348 def FromXml(self
, Item
, Key
):
351 self
.Header
.FromXml(Item
, Key
)
352 NewItem
= XmlNode(Item
, '%s/Header' % Key
)
353 self
.Header
.FromXml(NewItem
, 'Header')
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":
360 elif Executable
.upper() == "FALSE":
364 self
.Files
.append([Filename
, Executable
])
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
)
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
)
381 # This API is used for DistP's tool section
383 def FromXml2(self
, Item
, Key
):
387 NewItem
= XmlNode(Item
, '%s/Header' % Key
)
388 self
.Header
.FromXml(NewItem
, 'Header')
390 for SubItem
in XmlList(Item
, '%s/Filename' % Key
):
391 Filename
= XmlElement(SubItem
, '%s/Filename' % Key
)
393 XmlAttribute(XmlNode(SubItem
, '%s/Filename' % Key
), 'Executable')
394 OsType
= XmlAttribute(XmlNode(SubItem
, '%s/Filename' % Key
), 'OS')
395 if Executable
.upper() == "TRUE":
397 elif Executable
.upper() == "FALSE":
401 self
.Files
.append([Filename
, Executable
, OsType
])
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
)
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
)
421 # This API is used for Package or Module's MiscellaneousFile section
423 def ToXml(self
, MiscFile
, Key
):
427 NodeList
= [['Copyright', MiscFile
.GetCopyright()],
428 ['License', MiscFile
.GetLicense()],
429 ['Abstract', MiscFile
.GetAbstract()],
430 ['Description', MiscFile
.GetDescription()],
433 for File
in MiscFile
.GetFileList():
436 ('Filename', File
.GetURI(), [], \
437 [['Executable', str(File
.GetExecutable()).lower()]]))
438 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, [])
442 # This API is used for DistP's tool section
444 def ToXml2(self
, MiscFile
, Key
):
448 NodeList
= [['Name', MiscFile
.GetName()],
449 ['Copyright', MiscFile
.GetCopyright()],
450 ['License', MiscFile
.GetLicense()],
451 ['Abstract', MiscFile
.GetAbstract()],
452 ['Description', MiscFile
.GetDescription()],
454 HeaderNode
= CreateXmlElement('Header', '', NodeList
, [])
455 NodeList
= [HeaderNode
]
457 for File
in MiscFile
.GetFileList():
460 ('Filename', File
.GetURI(), [], \
461 [['Executable', str(File
.GetExecutable()).lower()], \
462 ['OS', File
.GetOS()]]))
463 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, [])
468 Str
= str(self
.Header
)
469 for Item
in self
.Files
:
470 Str
= Str
+ '\n\tFilename:' + str(Item
)
475 class UserExtensionsXml(object):
480 self
.BuildOptionDict
= {}
481 self
.IncludesDict
= {}
482 self
.SourcesDict
= {}
483 self
.BinariesDict
= {}
484 self
.SupArchList
= []
487 self
.BuildOptions
= ''
489 def FromXml2(self
, Item
, Key
):
490 self
.UserId
= XmlAttribute(XmlNode(Item
, '%s' % Key
), 'UserId')
491 self
.Identifier
= XmlAttribute(XmlNode(Item
, '%s' % Key
), 'Identifier')
493 UserExtension
= UserExtensionObject()
494 UserExtension
.SetUserID(self
.UserId
)
495 UserExtension
.SetIdentifier(self
.Identifier
)
499 def FromXml(self
, Item
, Key
):
500 self
.UserId
= XmlAttribute(XmlNode(Item
, '%s' % Key
), 'UserId')
501 self
.Identifier
= XmlAttribute(XmlNode(Item
, '%s' % Key
), 'Identifier')
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
] = ""
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
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
520 SourcesItem
= XmlNode(Item
, '%s/Sources' % Key
)
521 Tmp
= UserExtensionSourceXml()
522 SourceDict
= Tmp
.FromXml(SourcesItem
, 'Sources')
523 self
.SourcesDict
= SourceDict
525 BinariesItem
= XmlNode(Item
, '%s/Binaries' % Key
)
526 Tmp
= UserExtensionBinaryXml()
527 BinariesDict
= Tmp
.FromXml(BinariesItem
, 'Binaries')
528 self
.BinariesDict
= BinariesDict
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
]
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
)
547 def ToXml(self
, UserExtension
, Key
):
551 AttributeList
= [['UserId', str(UserExtension
.GetUserID())],
552 ['Identifier', str(UserExtension
.GetIdentifier())],
554 GetStringOfList(UserExtension
.GetSupArchList())],
557 Root
= CreateXmlElement('%s' % Key
, UserExtension
.GetStatement(), [], \
561 DefineDict
= UserExtension
.GetDefinesDict()
563 for Item
in DefineDict
.keys():
564 NodeList
.append(CreateXmlElement\
565 ('Statement', Item
, [], []))
566 DefineElement
= CreateXmlElement('Define', '', NodeList
, [])
567 Root
.appendChild(DefineElement
)
570 BuildOptionDict
= UserExtension
.GetBuildOptionDict()
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
)
581 IncludesDict
= UserExtension
.GetIncludesDict()
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
)
591 SourcesDict
= UserExtension
.GetSourcesDict()
593 Tmp
= UserExtensionSourceXml()
594 Root
.appendChild(Tmp
.ToXml(SourcesDict
, 'Sources'))
597 BinariesDict
= UserExtension
.GetBinariesDict()
599 Tmp
= UserExtensionBinaryXml()
600 Root
.appendChild(Tmp
.ToXml(BinariesDict
, 'Binaries'))
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
)
611 # UserExtensionSourceXml
613 class UserExtensionSourceXml(object):
615 self
.UserExtensionSource
= ''
617 def FromXml(self
, Item
, Key
):
620 if self
.UserExtensionSource
:
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
)
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
== ' '):
645 ValueList
.append((TagName
, ToolCode
, Comment
))
647 Dict
[DictKey
] = ValueList
651 def ToXml(self
, Dict
, Key
):
652 if self
.UserExtensionSource
:
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
:
665 if not (TagName
or ToolCode
or Comment
):
669 ValueNodeList
.append(["TagName", TagName
])
670 ValueNodeList
.append(["ToolCode", ToolCode
])
671 ValueNodeList
.append(["Comment", Comment
])
672 ValueNodeXml
= CreateXmlElement('SourceFileOtherAttr', '', \
674 SourceFileNodeList
.append(ValueNodeXml
)
675 SourceFileNodeXml
= CreateXmlElement('SourceFile', '', \
676 SourceFileNodeList
, [])
677 SourcesNodeList
.append(SourceFileNodeXml
)
678 Root
= CreateXmlElement('%s' % Key
, '', SourcesNodeList
, [])
682 # UserExtensionBinaryXml
684 class UserExtensionBinaryXml(object):
686 self
.UserExtensionBinary
= ''
688 def FromXml(self
, Item
, Key
):
691 if self
.UserExtensionBinary
:
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
)
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
== ' '):
721 ValueList
.append((Target
, Family
, TagName
, Comment
))
723 Dict
[DictKey
] = ValueList
727 def ToXml(self
, Dict
, Key
):
728 if self
.UserExtensionBinary
:
730 BinariesNodeList
= []
732 ValueList
= Dict
[Item
]
733 (FileName
, FileType
, FeatureFlag
, SupArch
) = Item
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
:
741 if not (Target
or Family
or TagName
or 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', '', \
752 FileNodeList
.append(ValueNodeXml
)
753 FileNodeXml
= CreateXmlElement('Binary', '', FileNodeList
, [])
754 BinariesNodeList
.append(FileNodeXml
)
755 Root
= CreateXmlElement('%s' % Key
, '', BinariesNodeList
, [])
761 class LibraryClassXml(object):
765 self
.RecommendedInstanceGuid
= ''
766 self
.RecommendedInstanceVersion
= ''
767 self
.CommonDefines
= CommonDefinesXml()
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
)
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
))
793 def ToXml(self
, LibraryClass
, Key
):
797 [['Keyword', LibraryClass
.GetLibraryClass()],
798 ['SupArchList', GetStringOfList(LibraryClass
.GetSupArchList())],
799 ['SupModList', GetStringOfList(LibraryClass
.GetSupModuleList())]
801 NodeList
= [['HeaderFile', LibraryClass
.GetIncludeHeader()]]
802 for Item
in LibraryClass
.GetHelpTextList():
804 NodeList
.append(Tmp
.ToXml(Item
))
806 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, AttributeList
)
810 def ToXml2(self
, LibraryClass
, Key
):
814 FeatureFlag
= ConvertNEToNOTEQ(LibraryClass
.GetFeatureFlag())
817 [['Usage', LibraryClass
.GetUsage()], \
818 ['SupArchList', GetStringOfList(LibraryClass
.GetSupArchList())], \
819 ['SupModList', GetStringOfList(LibraryClass
.GetSupModuleList())], \
820 ['FeatureFlag', FeatureFlag
]
822 NodeList
= [['Keyword', LibraryClass
.GetLibraryClass()], ]
823 for Item
in LibraryClass
.GetHelpTextList():
825 NodeList
.append(Tmp
.ToXml(Item
))
827 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, AttributeList
)
832 Str
= "Keyword = %s HeaderFile = %s RecommendedInstanceGuid = %s RecommendedInstanceVersion = %s %s" % \
833 (self
.Keyword
, self
.HeaderFile
, self
.RecommendedInstanceGuid
, self
.RecommendedInstanceVersion
, \
835 for Item
in self
.HelpText
:
836 Str
= Str
+ "\n\t" + str(Item
)
842 class FilenameXml(object):
846 self
.CommonDefines
= CommonDefinesXml()
848 def FromXml(self
, Item
, Key
):
849 self
.FileType
= XmlAttribute(Item
, 'FileType')
850 self
.Filename
= XmlElement(Item
, 'Filename')
851 self
.CommonDefines
.FromXml(Item
, Key
)
853 FeatureFlag
= ConvertNOTEQToNE(self
.CommonDefines
.FeatureFlag
)
855 Filename
= FileNameObject()
859 if self
.FileType
== 'UEFI_IMAGE':
860 self
.FileType
= 'PE32'
862 Filename
.SetFileType(self
.FileType
)
863 Filename
.SetFilename(self
.Filename
)
864 Filename
.SetSupArchList(self
.CommonDefines
.SupArchList
)
865 Filename
.SetFeatureFlag(FeatureFlag
)
869 def ToXml(self
, Filename
, Key
):
872 AttributeList
= [['SupArchList', \
873 GetStringOfList(Filename
.GetSupArchList())],
874 ['FileType', Filename
.GetFileType()],
875 ['FeatureFlag', ConvertNEToNOTEQ(Filename
.GetFeatureFlag())],
877 Root
= CreateXmlElement('%s' % Key
, Filename
.GetFilename(), [], AttributeList
)
882 return "FileType = %s Filename = %s %s" \
883 % (self
.FileType
, self
.Filename
, self
.CommonDefines
)