2 # This file is used to parse a PCD file of .PKG file
4 # Copyright (c) 2011 - 2018, 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
.StringUtils
import ConvertNEToNOTEQ
25 from Library
.StringUtils
import ConvertNOTEQToNE
26 from Library
.StringUtils
import GetSplitValueList
27 from Library
.StringUtils
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 Library
.UniClassObject
import ConvertSpecialUnicodes
35 from Library
.UniClassObject
import GetLanguageCode1766
36 from Object
.POM
.CommonObject
import FileObject
37 from Object
.POM
.CommonObject
import MiscFileObject
38 from Object
.POM
.CommonObject
import UserExtensionObject
39 from Object
.POM
.CommonObject
import ClonedRecordObject
40 from Object
.POM
.CommonObject
import LibraryClassObject
41 from Object
.POM
.CommonObject
import FileNameObject
42 from Object
.POM
.ModuleObject
import ModuleObject
43 from Xml
.XmlParserMisc
import IsRequiredItemListNull
44 from Xml
.XmlParserMisc
import GetHelpTextList
45 import Library
.DataType
as DataType
50 class ClonedFromXml(object):
55 def FromXml(self
, Item
, Key
):
56 self
.GUID
= XmlElement(Item
, '%s/GUID' % Key
)
57 self
.Version
= XmlAttribute(XmlNode(Item
, '%s/GUID' % Key
), 'Version')
58 if self
.GUID
== '' and self
.Version
== '':
60 ClonedFrom
= ClonedRecordObject()
61 ClonedFrom
.SetPackageGuid(self
.GUID
)
62 ClonedFrom
.SetPackageVersion(self
.Version
)
65 def ToXml(self
, ClonedFrom
, Key
):
68 Element1
= CreateXmlElement('GUID', ClonedFrom
.GetPackageGuid(), [],
69 [['Version', ClonedFrom
.GetPackageVersion()]])
72 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, AttributeList
)
76 return "GUID = %s Version = %s" % (self
.GUID
, self
.Version
)
82 class CommonDefinesXml(object):
89 def FromXml(self
, Item
, Key
):
92 self
.Usage
= XmlAttribute(Item
, 'Usage')
94 [Arch
for Arch
in GetSplitValueList(XmlAttribute(Item
, 'SupArchList'), DataType
.TAB_SPACE_SPLIT
) if Arch
]
96 [Mod
for Mod
in GetSplitValueList(XmlAttribute(Item
, 'SupModList'), DataType
.TAB_SPACE_SPLIT
) if Mod
]
97 self
.FeatureFlag
= ConvertNOTEQToNE(XmlAttribute(Item
, 'FeatureFlag'))
103 return "Usage = %s SupArchList = %s SupModList = %s FeatureFlag = %s" \
104 % (self
.Usage
, self
.SupArchList
, self
.SupModList
, self
.FeatureFlag
)
109 class PromptXml(object):
114 def FromXml(self
, Item
, Key
):
117 self
.Prompt
= XmlElement2(Item
, 'Prompt')
118 self
.Lang
= XmlAttribute(Item
, 'Lang')
120 def ToXml(self
, Prompt
, Key
='Prompt'):
123 return CreateXmlElement('%s' % Key
, Prompt
.GetString(), [], [['Lang', Prompt
.GetLang()]])
125 return "Prompt = %s Lang = %s" % (self
.Prompt
, self
.Lang
)
130 class HelpTextXml(object):
135 def FromXml(self
, Item
, Key
):
138 self
.HelpText
= XmlElement2(Item
, 'HelpText')
139 self
.Lang
= XmlAttribute(Item
, 'Lang')
141 def ToXml(self
, HelpText
, Key
='HelpText'):
144 return CreateXmlElement('%s' % Key
, HelpText
.GetString(), [], [['Lang', HelpText
.GetLang()]])
146 return "HelpText = %s Lang = %s" % (self
.HelpText
, self
.Lang
)
151 class HeaderXml(object):
157 self
.CopyrightList
= []
158 self
.LicenseList
= []
159 self
.AbstractList
= []
160 self
.DescriptionList
= []
162 def FromXml(self
, Item
, Key
, IsRequiredCheck
=False, IsStandAlongModule
=False):
163 if not Item
and IsRequiredCheck
:
165 if IsStandAlongModule
:
166 XmlTreeLevel
= ['DistributionPackage', 'ModuleSurfaceArea']
168 XmlTreeLevel
= ['DistributionPackage', 'PackageSurfaceArea', 'ModuleSurfaceArea']
169 CheckDict
= {'Header':''}
170 IsRequiredItemListNull(CheckDict
, XmlTreeLevel
)
171 self
.Name
= XmlElement(Item
, '%s/Name' % Key
)
172 self
.BaseName
= XmlAttribute(XmlNode(Item
, '%s/Name' % Key
), 'BaseName')
173 self
.GUID
= XmlElement(Item
, '%s/GUID' % Key
)
174 self
.Version
= XmlAttribute(XmlNode(Item
, '%s/GUID' % Key
), 'Version')
176 for SubItem
in XmlList(Item
, '%s/Abstract' % Key
):
177 HeaderAbstractLang
= XmlAttribute(SubItem
, 'Lang')
178 self
.AbstractList
.append((HeaderAbstractLang
, XmlElement(SubItem
, '%s/Abstract' % Key
)))
179 for SubItem
in XmlList(Item
, '%s/Description' % Key
):
180 HeaderDescriptionLang
= XmlAttribute(SubItem
, 'Lang')
181 self
.DescriptionList
.append((HeaderDescriptionLang
, XmlElement(SubItem
, '%s/Description' % Key
)))
182 for SubItem
in XmlList(Item
, '%s/Copyright' % Key
):
183 HeaderCopyrightLang
= XmlAttribute(SubItem
, 'Lang')
184 self
.CopyrightList
.append((HeaderCopyrightLang
, XmlElement(SubItem
, '%s/Copyright' % Key
)))
185 for SubItem
in XmlList(Item
, '%s/License' % Key
):
186 HeaderLicenseLang
= XmlAttribute(SubItem
, 'Lang')
187 self
.LicenseList
.append((HeaderLicenseLang
, XmlElement(SubItem
, '%s/License' % Key
)))
188 ModuleHeader
= ModuleObject()
189 ModuleHeader
.SetName(self
.Name
)
190 ModuleHeader
.SetBaseName(self
.BaseName
)
191 ModuleHeader
.SetGuid(self
.GUID
)
192 ModuleHeader
.SetVersion(self
.Version
)
193 ModuleHeader
.SetCopyright(self
.CopyrightList
)
194 ModuleHeader
.SetLicense(self
.LicenseList
)
195 ModuleHeader
.SetAbstract(self
.AbstractList
)
196 ModuleHeader
.SetDescription(self
.DescriptionList
)
199 def ToXml(self
, Header
, Key
):
202 Element1
= CreateXmlElement('Name', Header
.GetName(), [], [['BaseName', Header
.GetBaseName()]])
203 Element2
= CreateXmlElement('GUID', Header
.GetGuid(), [], [['Version', Header
.GetVersion()]])
204 NodeList
= [Element1
,
208 UNIInfAbstractList
= []
209 UNIInfDescriptionList
= []
210 # Get Abstract and Description from Uni File
211 # if the Uni File exists
212 if Header
.UniFileClassObject
is not None:
213 UniStrDict
= Header
.UniFileClassObject
.OrderedStringList
214 for Lang
in UniStrDict
:
215 for StringDefClassObject
in UniStrDict
[Lang
]:
216 if not StringDefClassObject
.StringValue
:
218 if StringDefClassObject
.StringName
== DataType
.TAB_INF_ABSTRACT
:
219 UNIInfAbstractList
.append((GetLanguageCode1766(Lang
),
220 ConvertSpecialUnicodes(StringDefClassObject
.StringValue
)))
222 if StringDefClassObject
.StringName
== DataType
.TAB_INF_DESCRIPTION
:
223 UNIInfDescriptionList
.append((GetLanguageCode1766(Lang
),
224 ConvertSpecialUnicodes(StringDefClassObject
.StringValue
)))
226 # Get Abstract and Description from INF File Header
227 for (Lang
, Value
) in Header
.GetCopyright():
229 NodeList
.append(CreateXmlElement('Copyright', Value
, [], []))
230 for (Lang
, Value
) in Header
.GetLicense():
232 NodeList
.append(CreateXmlElement('License', Value
, [], []))
233 for (Lang
, Value
) in Header
.GetAbstract() + UNIInfAbstractList
:
235 NodeList
.append(CreateXmlElement('Abstract', Value
, [], [['Lang', Lang
]]))
236 for (Lang
, Value
) in Header
.GetDescription() + UNIInfDescriptionList
:
238 NodeList
.append(CreateXmlElement('Description', Value
, [], [['Lang', Lang
]]))
241 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, AttributeList
)
245 return "Name = %s BaseName = %s GUID = %s Version = %s Copyright = %s \
246 License = %s Abstract = %s Description = %s" % \
247 (self
.Name
, self
.BaseName
, self
.GUID
, self
.Version
, self
.CopyrightList
, \
248 self
.LicenseList
, self
.AbstractList
, self
.DescriptionList
)
250 # DistributionPackageHeaderXml
252 class DistributionPackageHeaderXml(object):
254 self
.Header
= HeaderXml()
260 self
.XmlSpecification
= ''
262 def FromXml(self
, Item
, Key
):
265 self
.ReadOnly
= XmlAttribute(XmlNode(Item
, '%s' % Key
), 'ReadOnly')
266 self
.RePackage
= XmlAttribute(XmlNode(Item
, '%s' % Key
), 'RePackage')
267 self
.Vendor
= XmlElement(Item
, '%s/Vendor' % Key
)
268 self
.Date
= XmlElement(Item
, '%s/Date' % Key
)
269 self
.Signature
= XmlElement(Item
, '%s/Signature' % Key
)
270 self
.XmlSpecification
= XmlElement(Item
, '%s/XmlSpecification' % Key
)
271 self
.Header
.FromXml(Item
, Key
)
272 DistributionPackageHeader
= DistributionPackageHeaderObject()
273 if self
.ReadOnly
.upper() == 'TRUE':
274 DistributionPackageHeader
.ReadOnly
= True
275 elif self
.ReadOnly
.upper() == 'FALSE':
276 DistributionPackageHeader
.ReadOnly
= False
277 if self
.RePackage
.upper() == 'TRUE':
278 DistributionPackageHeader
.RePackage
= True
279 elif self
.RePackage
.upper() == 'FALSE':
280 DistributionPackageHeader
.RePackage
= False
281 DistributionPackageHeader
.Vendor
= self
.Vendor
282 DistributionPackageHeader
.Date
= self
.Date
283 DistributionPackageHeader
.Signature
= self
.Signature
284 DistributionPackageHeader
.XmlSpecification
= self
.XmlSpecification
285 DistributionPackageHeader
.SetName(self
.Header
.Name
)
286 DistributionPackageHeader
.SetBaseName(self
.Header
.BaseName
)
287 DistributionPackageHeader
.SetGuid(self
.Header
.GUID
)
288 DistributionPackageHeader
.SetVersion(self
.Header
.Version
)
289 DistributionPackageHeader
.SetCopyright(self
.Header
.CopyrightList
)
290 DistributionPackageHeader
.SetLicense(self
.Header
.LicenseList
)
291 DistributionPackageHeader
.SetAbstract(self
.Header
.AbstractList
)
292 DistributionPackageHeader
.SetDescription(self
.Header
.DescriptionList
)
293 return DistributionPackageHeader
295 def ToXml(self
, DistributionPackageHeader
, Key
):
298 Element1
= CreateXmlElement('Name', \
299 DistributionPackageHeader
.GetName(), [], \
301 DistributionPackageHeader
.GetBaseName()]])
302 Element2
= CreateXmlElement('GUID', \
303 DistributionPackageHeader
.GetGuid(), [], \
305 DistributionPackageHeader
.GetVersion()]])
307 if DistributionPackageHeader
.ReadOnly
!= '':
308 AttributeList
.append(['ReadOnly', str(DistributionPackageHeader
.ReadOnly
).lower()])
309 if DistributionPackageHeader
.RePackage
!= '':
310 AttributeList
.append(['RePackage', str(DistributionPackageHeader
.RePackage
).lower()])
311 if DistributionPackageHeader
.GetAbstract():
312 DPAbstract
= DistributionPackageHeader
.GetAbstract()[0][1]
315 if DistributionPackageHeader
.GetDescription():
316 DPDescription
= DistributionPackageHeader
.GetDescription()[0][1]
319 if DistributionPackageHeader
.GetCopyright():
320 DPCopyright
= DistributionPackageHeader
.GetCopyright()[0][1]
323 if DistributionPackageHeader
.GetLicense():
324 DPLicense
= DistributionPackageHeader
.GetLicense()[0][1]
327 NodeList
= [Element1
,
329 ['Vendor', DistributionPackageHeader
.Vendor
],
330 ['Date', DistributionPackageHeader
.Date
],
331 ['Copyright', DPCopyright
],
332 ['License', DPLicense
],
333 ['Abstract', DPAbstract
],
334 ['Description', DPDescription
],
335 ['Signature', DistributionPackageHeader
.Signature
],
336 ['XmlSpecification', \
337 DistributionPackageHeader
.XmlSpecification
],
339 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, AttributeList
)
343 return "ReadOnly = %s RePackage = %s Vendor = %s Date = %s \
344 Signature = %s XmlSpecification = %s %s" % \
345 (self
.ReadOnly
, self
.RePackage
, self
.Vendor
, self
.Date
, \
346 self
.Signature
, self
.XmlSpecification
, self
.Header
)
350 class PackageHeaderXml(object):
352 self
.Header
= HeaderXml()
353 self
.PackagePath
= ''
355 def FromXml(self
, Item
, Key
, PackageObject2
):
357 XmlTreeLevel
= ['DistributionPackage', 'PackageSurfaceArea']
358 CheckDict
= {'PackageHeader': None, }
359 IsRequiredItemListNull(CheckDict
, XmlTreeLevel
)
360 self
.PackagePath
= XmlElement(Item
, '%s/PackagePath' % Key
)
361 self
.Header
.FromXml(Item
, Key
)
362 PackageObject2
.SetName(self
.Header
.Name
)
363 PackageObject2
.SetBaseName(self
.Header
.BaseName
)
364 PackageObject2
.SetGuid(self
.Header
.GUID
)
365 PackageObject2
.SetVersion(self
.Header
.Version
)
366 PackageObject2
.SetCopyright(self
.Header
.CopyrightList
)
367 PackageObject2
.SetLicense(self
.Header
.LicenseList
)
368 PackageObject2
.SetAbstract(self
.Header
.AbstractList
)
369 PackageObject2
.SetDescription(self
.Header
.DescriptionList
)
370 PackageObject2
.SetPackagePath(self
.PackagePath
)
372 def ToXml(self
, PackageObject2
, Key
):
375 Element1
= CreateXmlElement('Name', PackageObject2
.GetName(), [], \
376 [['BaseName', PackageObject2
.GetBaseName()]])
377 Element2
= CreateXmlElement('GUID', PackageObject2
.GetGuid(), [], \
378 [['Version', PackageObject2
.GetVersion()]])
379 NodeList
= [Element1
,
383 UNIPackageAbrstractList
= []
384 UNIPackageDescriptionList
= []
385 # Get Abstract and Description from Uni File
386 # if the Uni File exists
387 if PackageObject2
.UniFileClassObject
is not None:
388 UniStrDict
= PackageObject2
.UniFileClassObject
.OrderedStringList
389 for Lang
in UniStrDict
:
390 for StringDefClassObject
in UniStrDict
[Lang
]:
391 if not StringDefClassObject
.StringValue
:
393 if StringDefClassObject
.StringName
== DataType
.TAB_DEC_PACKAGE_ABSTRACT
:
394 UNIPackageAbrstractList
.append((GetLanguageCode1766(Lang
),
395 ConvertSpecialUnicodes(StringDefClassObject
.StringValue
)))
397 if StringDefClassObject
.StringName
== DataType
.TAB_DEC_PACKAGE_DESCRIPTION
:
398 UNIPackageDescriptionList
.append((GetLanguageCode1766(Lang
),
399 ConvertSpecialUnicodes(StringDefClassObject
.StringValue
)))
401 # Get Abstract and Description from DEC File Header
402 for (Lang
, Value
) in PackageObject2
.GetCopyright():
404 NodeList
.append(CreateXmlElement(DataType
.TAB_HEADER_COPYRIGHT
, Value
, [], []))
405 for (Lang
, Value
) in PackageObject2
.GetLicense():
407 NodeList
.append(CreateXmlElement(DataType
.TAB_HEADER_LICENSE
, Value
, [], []))
408 for (Lang
, Value
) in PackageObject2
.GetAbstract() + UNIPackageAbrstractList
:
410 NodeList
.append(CreateXmlElement(DataType
.TAB_HEADER_ABSTRACT
, Value
, [], [['Lang', Lang
]]))
411 for (Lang
, Value
) in PackageObject2
.GetDescription() + UNIPackageDescriptionList
:
413 NodeList
.append(CreateXmlElement(DataType
.TAB_HEADER_DESCRIPTION
, Value
, [], [['Lang', Lang
]]))
416 NodeList
.append(['PackagePath', PackageObject2
.GetPackagePath()])
418 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, AttributeList
)
422 return "PackagePath = %s %s" \
423 % (self
.PackagePath
, self
.Header
)
426 # MiscellaneousFileXml
428 class MiscellaneousFileXml(object):
430 self
.Header
= HeaderXml()
433 # This API is used for Package or Module's MiscellaneousFile section
435 def FromXml(self
, Item
, Key
):
438 self
.Header
.FromXml(Item
, Key
)
439 NewItem
= XmlNode(Item
, '%s/Header' % Key
)
440 self
.Header
.FromXml(NewItem
, 'Header')
441 for SubItem
in XmlList(Item
, '%s/Filename' % Key
):
442 Filename
= XmlElement(SubItem
, '%s/Filename' % Key
)
443 Executable
= XmlAttribute(XmlNode(SubItem
, '%s/Filename' % Key
), 'Executable')
444 if Executable
.upper() == "TRUE":
446 elif Executable
.upper() == "FALSE":
450 self
.Files
.append([Filename
, Executable
])
451 MiscFile
= MiscFileObject()
452 MiscFile
.SetCopyright(self
.Header
.CopyrightList
)
453 MiscFile
.SetLicense(self
.Header
.LicenseList
)
454 MiscFile
.SetAbstract(self
.Header
.AbstractList
)
455 MiscFile
.SetDescription(self
.Header
.DescriptionList
)
457 for File
in self
.Files
:
458 FileObj
= FileObject()
459 FileObj
.SetURI(File
[0])
460 FileObj
.SetExecutable(File
[1])
461 MiscFileList
.append(FileObj
)
462 MiscFile
.SetFileList(MiscFileList
)
465 # This API is used for DistP's tool section
467 def FromXml2(self
, Item
, Key
):
470 NewItem
= XmlNode(Item
, '%s/Header' % Key
)
471 self
.Header
.FromXml(NewItem
, 'Header')
472 for SubItem
in XmlList(Item
, '%s/Filename' % Key
):
473 Filename
= XmlElement(SubItem
, '%s/Filename' % Key
)
475 XmlAttribute(XmlNode(SubItem
, '%s/Filename' % Key
), 'Executable')
476 OsType
= XmlAttribute(XmlNode(SubItem
, '%s/Filename' % Key
), 'OS')
477 if Executable
.upper() == "TRUE":
479 elif Executable
.upper() == "FALSE":
483 self
.Files
.append([Filename
, Executable
, OsType
])
484 MiscFile
= MiscFileObject()
485 MiscFile
.SetName(self
.Header
.Name
)
486 MiscFile
.SetCopyright(self
.Header
.CopyrightList
)
487 MiscFile
.SetLicense(self
.Header
.LicenseList
)
488 MiscFile
.SetAbstract(self
.Header
.AbstractList
)
489 MiscFile
.SetDescription(self
.Header
.DescriptionList
)
491 for File
in self
.Files
:
492 FileObj
= FileObject()
493 FileObj
.SetURI(File
[0])
494 FileObj
.SetExecutable(File
[1])
495 FileObj
.SetOS(File
[2])
496 MiscFileList
.append(FileObj
)
497 MiscFile
.SetFileList(MiscFileList
)
501 # This API is used for Package or Module's MiscellaneousFile section
503 def ToXml(self
, MiscFile
, Key
):
507 if MiscFile
.GetAbstract():
508 DPAbstract
= MiscFile
.GetAbstract()[0][1]
511 if MiscFile
.GetDescription():
512 DPDescription
= MiscFile
.GetDescription()[0][1]
515 if MiscFile
.GetCopyright():
516 DPCopyright
= MiscFile
.GetCopyright()[0][1]
519 if MiscFile
.GetLicense():
520 DPLicense
= MiscFile
.GetLicense()[0][1]
523 NodeList
= [['Copyright', DPCopyright
],
524 ['License', DPLicense
],
525 ['Abstract', DPAbstract
],
526 ['Description', DPDescription
],
528 for File
in MiscFile
.GetFileList():
531 ('Filename', File
.GetURI(), [], \
532 [['Executable', str(File
.GetExecutable()).lower()]]))
533 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, [])
536 # This API is used for DistP's tool section
538 def ToXml2(self
, MiscFile
, Key
):
542 if MiscFile
.GetAbstract():
543 DPAbstract
= MiscFile
.GetAbstract()[0][1]
546 if MiscFile
.GetDescription():
547 DPDescription
= MiscFile
.GetDescription()[0][1]
550 if MiscFile
.GetCopyright():
551 DPCopyright
= MiscFile
.GetCopyright()[0][1]
554 if MiscFile
.GetLicense():
555 DPLicense
= MiscFile
.GetLicense()[0][1]
558 NodeList
= [['Name', MiscFile
.GetName()],
559 ['Copyright', DPCopyright
],
560 ['License', DPLicense
],
561 ['Abstract', DPAbstract
],
562 ['Description', DPDescription
],
564 HeaderNode
= CreateXmlElement('Header', '', NodeList
, [])
565 NodeList
= [HeaderNode
]
566 for File
in MiscFile
.GetFileList():
569 ('Filename', File
.GetURI(), [], \
570 [['Executable', str(File
.GetExecutable()).lower()], \
571 ['OS', File
.GetOS()]]))
572 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, [])
576 Str
= str(self
.Header
)
577 for Item
in self
.Files
:
578 Str
= Str
+ '\n\tFilename:' + str(Item
)
583 class UserExtensionsXml(object):
587 self
.BinaryAbstractList
= []
588 self
.BinaryDescriptionList
= []
589 self
.BinaryCopyrightList
= []
590 self
.BinaryLicenseList
= []
591 self
.LangDefsList
= []
593 self
.BuildOptionDict
= {}
594 self
.IncludesDict
= {}
595 self
.SourcesDict
= {}
596 self
.BinariesDict
= {}
597 self
.SupArchList
= []
600 self
.BuildOptions
= ''
602 def FromXml2(self
, Item
, Key
):
603 self
.UserId
= XmlAttribute(XmlNode(Item
, '%s' % Key
), 'UserId')
604 self
.Identifier
= XmlAttribute(XmlNode(Item
, '%s' % Key
), 'Identifier')
605 UserExtension
= UserExtensionObject()
606 UserExtension
.SetUserID(self
.UserId
)
607 UserExtension
.SetIdentifier(self
.Identifier
)
610 def FromXml(self
, Item
, Key
):
611 self
.UserId
= XmlAttribute(XmlNode(Item
, '%s' % Key
), 'UserId')
612 self
.Identifier
= XmlAttribute(XmlNode(Item
, '%s' % Key
), 'Identifier')
613 if self
.UserId
== DataType
.TAB_BINARY_HEADER_USERID \
614 and self
.Identifier
== DataType
.TAB_BINARY_HEADER_IDENTIFIER
:
615 for SubItem
in XmlList(Item
, '%s/BinaryAbstract' % Key
):
616 BinaryAbstractLang
= XmlAttribute(SubItem
, 'Lang')
617 self
.BinaryAbstractList
.append((BinaryAbstractLang
, XmlElement(SubItem
, '%s/BinaryAbstract' % Key
)))
618 for SubItem
in XmlList(Item
, '%s/BinaryDescription' % Key
):
619 BinaryDescriptionLang
= XmlAttribute(SubItem
, 'Lang')
620 self
.BinaryDescriptionList
.append((BinaryDescriptionLang
,
621 XmlElement(SubItem
, '%s/BinaryDescription' % Key
)))
622 for SubItem
in XmlList(Item
, '%s/BinaryCopyright' % Key
):
623 BinaryCopyrightLang
= XmlAttribute(SubItem
, 'Lang')
624 self
.BinaryCopyrightList
.append((BinaryCopyrightLang
,
625 XmlElement(SubItem
, '%s/BinaryCopyright' % Key
)))
626 for SubItem
in XmlList(Item
, '%s/BinaryLicense' % Key
):
627 BinaryLicenseLang
= XmlAttribute(SubItem
, 'Lang')
628 self
.BinaryLicenseList
.append((BinaryLicenseLang
,
629 XmlElement(SubItem
, '%s/BinaryLicense' % Key
)))
631 DefineItem
= XmlNode(Item
, '%s/Define' % Key
)
632 for SubItem
in XmlList(DefineItem
, 'Define/Statement'):
633 Statement
= XmlElement(SubItem
, '%s/Statement' % Key
)
634 self
.DefineDict
[Statement
] = ""
635 BuildOptionItem
= XmlNode(Item
, '%s/BuildOption' % Key
)
636 for SubItem
in XmlList(BuildOptionItem
, 'BuildOption/Statement'):
637 Statement
= XmlElement(SubItem
, '%s/Statement' % Key
)
638 Arch
= XmlAttribute(XmlNode(SubItem
, '%s/Statement' % Key
), 'SupArchList')
639 self
.BuildOptionDict
[Arch
] = Statement
640 IncludesItem
= XmlNode(Item
, '%s/Includes' % Key
)
641 for SubItem
in XmlList(IncludesItem
, 'Includes/Statement'):
642 Statement
= XmlElement(SubItem
, '%s/Statement' % Key
)
643 Arch
= XmlAttribute(XmlNode(SubItem
, '%s/Statement' % Key
), 'SupArchList')
644 self
.IncludesDict
[Statement
] = Arch
645 SourcesItem
= XmlNode(Item
, '%s/Sources' % Key
)
646 Tmp
= UserExtensionSourceXml()
647 SourceDict
= Tmp
.FromXml(SourcesItem
, 'Sources')
648 self
.SourcesDict
= SourceDict
649 BinariesItem
= XmlNode(Item
, '%s/Binaries' % Key
)
650 Tmp
= UserExtensionBinaryXml()
651 BinariesDict
= Tmp
.FromXml(BinariesItem
, 'Binaries')
652 self
.BinariesDict
= BinariesDict
653 self
.Statement
= XmlElement(Item
, 'UserExtensions')
654 SupArch
= XmlAttribute(XmlNode(Item
, '%s' % Key
), 'SupArchList')
655 self
.SupArchList
= [Arch
for Arch
in GetSplitValueList(SupArch
, DataType
.TAB_SPACE_SPLIT
) if Arch
]
656 UserExtension
= UserExtensionObject()
657 UserExtension
.SetUserID(self
.UserId
)
658 UserExtension
.SetIdentifier(self
.Identifier
)
659 UserExtension
.SetBinaryAbstract(self
.BinaryAbstractList
)
660 UserExtension
.SetBinaryDescription(self
.BinaryDescriptionList
)
661 UserExtension
.SetBinaryCopyright(self
.BinaryCopyrightList
)
662 UserExtension
.SetBinaryLicense(self
.BinaryLicenseList
)
663 UserExtension
.SetStatement(self
.Statement
)
664 UserExtension
.SetSupArchList(self
.SupArchList
)
665 UserExtension
.SetDefinesDict(self
.DefineDict
)
666 UserExtension
.SetBuildOptionDict(self
.BuildOptionDict
)
667 UserExtension
.SetIncludesDict(self
.IncludesDict
)
668 UserExtension
.SetSourcesDict(self
.SourcesDict
)
669 UserExtension
.SetBinariesDict(self
.BinariesDict
)
672 def ToXml(self
, UserExtension
, Key
):
675 AttributeList
= [['UserId', str(UserExtension
.GetUserID())],
676 ['Identifier', str(UserExtension
.GetIdentifier())],
678 GetStringOfList(UserExtension
.GetSupArchList())],
680 Root
= CreateXmlElement('%s' % Key
, UserExtension
.GetStatement(), [], \
682 if UserExtension
.GetIdentifier() == DataType
.TAB_BINARY_HEADER_IDENTIFIER
and \
683 UserExtension
.GetUserID() == DataType
.TAB_BINARY_HEADER_USERID
:
684 for (Lang
, Value
) in UserExtension
.GetBinaryAbstract():
686 ChildElement
= CreateXmlElement('BinaryAbstract', Value
, [], [['Lang', Lang
]])
687 Root
.appendChild(ChildElement
)
688 for (Lang
, Value
) in UserExtension
.GetBinaryDescription():
690 ChildElement
= CreateXmlElement('BinaryDescription', Value
, [], [['Lang', Lang
]])
691 Root
.appendChild(ChildElement
)
692 for (Lang
, Value
) in UserExtension
.GetBinaryCopyright():
694 ChildElement
= CreateXmlElement('BinaryCopyright', Value
, [], [])
695 Root
.appendChild(ChildElement
)
696 for (Lang
, Value
) in UserExtension
.GetBinaryLicense():
698 ChildElement
= CreateXmlElement('BinaryLicense', Value
, [], [])
699 Root
.appendChild(ChildElement
)
702 DefineDict
= UserExtension
.GetDefinesDict()
704 for Item
in DefineDict
.keys():
705 NodeList
.append(CreateXmlElement\
706 ('Statement', Item
, [], []))
707 DefineElement
= CreateXmlElement('Define', '', NodeList
, [])
708 Root
.appendChild(DefineElement
)
710 BuildOptionDict
= UserExtension
.GetBuildOptionDict()
712 for Item
in BuildOptionDict
.keys():
713 NodeList
.append(CreateXmlElement\
714 ('Statement', BuildOptionDict
[Item
], [], \
715 [['SupArchList', Item
]]))
716 BuildOptionElement
= \
717 CreateXmlElement('BuildOption', '', NodeList
, [])
718 Root
.appendChild(BuildOptionElement
)
720 IncludesDict
= UserExtension
.GetIncludesDict()
722 for Item
in IncludesDict
.keys():
723 NodeList
.append(CreateXmlElement\
724 ('Statement', Item
, [], \
725 [['SupArchList', IncludesDict
[Item
]]]))
726 IncludesElement
= CreateXmlElement('Includes', '', NodeList
, [])
727 Root
.appendChild(IncludesElement
)
729 SourcesDict
= UserExtension
.GetSourcesDict()
731 Tmp
= UserExtensionSourceXml()
732 Root
.appendChild(Tmp
.ToXml(SourcesDict
, 'Sources'))
734 BinariesDict
= UserExtension
.GetBinariesDict()
736 Tmp
= UserExtensionBinaryXml()
737 Root
.appendChild(Tmp
.ToXml(BinariesDict
, 'Binaries'))
741 Str
= "UserId = %s Identifier = %s" % (self
.UserId
, self
.Identifier
)
742 Str
= Str
+ '\n\tDefines:' + str(self
.Defines
)
743 Str
= Str
+ '\n\tBuildOptions:' + str(self
.BuildOptions
)
747 # UserExtensionSourceXml
749 class UserExtensionSourceXml(object):
751 self
.UserExtensionSource
= ''
753 def FromXml(self
, Item
, Key
):
756 if self
.UserExtensionSource
:
759 #SourcesItem = XmlNode(Item, '%s/Sources' % Key)
760 for SubItem
in XmlList(Item
, 'Sources/SourceFile'):
761 FileName
= XmlElement(SubItem
, 'SourceFile/FileName')
762 Family
= XmlElement(SubItem
, 'SourceFile/Family')
763 FeatureFlag
= XmlElement(SubItem
, 'SourceFile/FeatureFlag')
764 SupArchStr
= XmlElement(SubItem
, 'SourceFile/SupArchList')
765 DictKey
= (FileName
, Family
, FeatureFlag
, SupArchStr
)
767 for ValueNodeItem
in XmlList(SubItem
, \
768 'SourceFile/SourceFileOtherAttr'):
769 TagName
= XmlElement(ValueNodeItem
, \
770 'SourceFileOtherAttr/TagName')
771 ToolCode
= XmlElement(ValueNodeItem
, \
772 'SourceFileOtherAttr/ToolCode')
773 Comment
= XmlElement(ValueNodeItem
, \
774 'SourceFileOtherAttr/Comment')
775 if (TagName
== ' ') and (ToolCode
== ' ') and (Comment
== ' '):
779 ValueList
.append((TagName
, ToolCode
, Comment
))
780 Dict
[DictKey
] = ValueList
783 def ToXml(self
, Dict
, Key
):
784 if self
.UserExtensionSource
:
788 ValueList
= Dict
[Item
]
789 (FileName
, Family
, FeatureFlag
, SupArchStr
) = Item
790 SourceFileNodeList
= []
791 SourceFileNodeList
.append(["FileName", FileName
])
792 SourceFileNodeList
.append(["Family", Family
])
793 SourceFileNodeList
.append(["FeatureFlag", FeatureFlag
])
794 SourceFileNodeList
.append(["SupArchList", SupArchStr
])
795 for (TagName
, ToolCode
, Comment
) in ValueList
:
797 if not (TagName
or ToolCode
or Comment
):
801 ValueNodeList
.append(["TagName", TagName
])
802 ValueNodeList
.append(["ToolCode", ToolCode
])
803 ValueNodeList
.append(["Comment", Comment
])
804 ValueNodeXml
= CreateXmlElement('SourceFileOtherAttr', '', \
806 SourceFileNodeList
.append(ValueNodeXml
)
807 SourceFileNodeXml
= CreateXmlElement('SourceFile', '', \
808 SourceFileNodeList
, [])
809 SourcesNodeList
.append(SourceFileNodeXml
)
810 Root
= CreateXmlElement('%s' % Key
, '', SourcesNodeList
, [])
814 # UserExtensionBinaryXml
816 class UserExtensionBinaryXml(object):
818 self
.UserExtensionBinary
= ''
820 def FromXml(self
, Item
, Key
):
823 if self
.UserExtensionBinary
:
826 for SubItem
in XmlList(Item
, 'Binaries/Binary'):
827 FileName
= XmlElement(SubItem
, 'Binary/FileName')
828 FileType
= XmlElement(SubItem
, 'Binary/FileType')
829 FFE
= XmlElement(SubItem
, 'Binary/FeatureFlag')
830 SupArch
= XmlElement(SubItem
, 'Binary/SupArchList')
831 DictKey
= (FileName
, FileType
, ConvertNOTEQToNE(FFE
), SupArch
)
833 for ValueNodeItem
in XmlList(SubItem
, \
834 'Binary/BinaryFileOtherAttr'):
835 Target
= XmlElement(ValueNodeItem
, \
836 'BinaryFileOtherAttr/Target')
837 Family
= XmlElement(ValueNodeItem
, \
838 'BinaryFileOtherAttr/Family')
839 TagName
= XmlElement(ValueNodeItem
, \
840 'BinaryFileOtherAttr/TagName')
841 Comment
= XmlElement(ValueNodeItem
, \
842 'BinaryFileOtherAttr/Comment')
843 if (Target
== ' ') and (Family
== ' ') and \
844 (TagName
== ' ') and (Comment
== ' '):
850 ValueList
.append((Target
, Family
, TagName
, Comment
))
851 Dict
[DictKey
] = ValueList
854 def ToXml(self
, Dict
, Key
):
855 if self
.UserExtensionBinary
:
857 BinariesNodeList
= []
859 ValueList
= Dict
[Item
]
860 (FileName
, FileType
, FeatureFlag
, SupArch
) = Item
862 FileNodeList
.append(["FileName", FileName
])
863 FileNodeList
.append(["FileType", FileType
])
864 FileNodeList
.append(["FeatureFlag", ConvertNEToNOTEQ(FeatureFlag
)])
865 FileNodeList
.append(["SupArchList", SupArch
])
866 for (Target
, Family
, TagName
, Comment
) in ValueList
:
868 if not (Target
or Family
or TagName
or Comment
):
873 ValueNodeList
.append(["Target", Target
])
874 ValueNodeList
.append(["Family", Family
])
875 ValueNodeList
.append(["TagName", TagName
])
876 ValueNodeList
.append(["Comment", Comment
])
877 ValueNodeXml
= CreateXmlElement('BinaryFileOtherAttr', '', \
879 FileNodeList
.append(ValueNodeXml
)
880 FileNodeXml
= CreateXmlElement('Binary', '', FileNodeList
, [])
881 BinariesNodeList
.append(FileNodeXml
)
882 Root
= CreateXmlElement('%s' % Key
, '', BinariesNodeList
, [])
888 class LibraryClassXml(object):
892 self
.RecommendedInstanceGuid
= ''
893 self
.RecommendedInstanceVersion
= ''
894 self
.CommonDefines
= CommonDefinesXml()
897 def FromXml(self
, Item
, Key
):
898 self
.Keyword
= XmlAttribute(XmlNode(Item
, '%s' % Key
), 'Keyword')
899 if self
.Keyword
== '':
900 self
.Keyword
= XmlElement(Item
, '%s/Keyword' % Key
)
901 self
.HeaderFile
= XmlElement(Item
, '%s/HeaderFile' % Key
)
902 self
.CommonDefines
.FromXml(XmlNode(Item
, '%s' % Key
), Key
)
903 for HelpTextItem
in XmlList(Item
, '%s/HelpText' % Key
):
904 HelpTextObj
= HelpTextXml()
905 HelpTextObj
.FromXml(HelpTextItem
, '%s/HelpText' % Key
)
906 self
.HelpText
.append(HelpTextObj
)
907 LibraryClass
= LibraryClassObject()
908 LibraryClass
.SetLibraryClass(self
.Keyword
)
909 LibraryClass
.SetIncludeHeader(self
.HeaderFile
)
910 if self
.CommonDefines
.Usage
:
911 LibraryClass
.SetUsage(self
.CommonDefines
.Usage
)
912 LibraryClass
.SetSupArchList(self
.CommonDefines
.SupArchList
)
913 LibraryClass
.SetSupModuleList(self
.CommonDefines
.SupModList
)
914 LibraryClass
.SetFeatureFlag(ConvertNOTEQToNE(self
.CommonDefines
.FeatureFlag
))
915 LibraryClass
.SetHelpTextList(GetHelpTextList(self
.HelpText
))
918 def ToXml(self
, LibraryClass
, Key
):
922 [['Keyword', LibraryClass
.GetLibraryClass()],
923 ['SupArchList', GetStringOfList(LibraryClass
.GetSupArchList())],
924 ['SupModList', GetStringOfList(LibraryClass
.GetSupModuleList())]
926 NodeList
= [['HeaderFile', LibraryClass
.GetIncludeHeader()]]
927 for Item
in LibraryClass
.GetHelpTextList():
929 NodeList
.append(Tmp
.ToXml(Item
))
930 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, AttributeList
)
933 def ToXml2(self
, LibraryClass
, Key
):
936 FeatureFlag
= ConvertNEToNOTEQ(LibraryClass
.GetFeatureFlag())
938 [['Usage', LibraryClass
.GetUsage()], \
939 ['SupArchList', GetStringOfList(LibraryClass
.GetSupArchList())], \
940 ['SupModList', GetStringOfList(LibraryClass
.GetSupModuleList())], \
941 ['FeatureFlag', FeatureFlag
]
943 NodeList
= [['Keyword', LibraryClass
.GetLibraryClass()], ]
944 for Item
in LibraryClass
.GetHelpTextList():
946 NodeList
.append(Tmp
.ToXml(Item
))
947 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, AttributeList
)
951 Str
= "Keyword = %s HeaderFile = %s RecommendedInstanceGuid = %s RecommendedInstanceVersion = %s %s" % \
952 (self
.Keyword
, self
.HeaderFile
, self
.RecommendedInstanceGuid
, self
.RecommendedInstanceVersion
, \
954 for Item
in self
.HelpText
:
955 Str
= Str
+ "\n\t" + str(Item
)
961 class FilenameXml(object):
965 self
.CommonDefines
= CommonDefinesXml()
967 def FromXml(self
, Item
, Key
):
968 self
.FileType
= XmlAttribute(Item
, 'FileType')
969 Guid
= XmlAttribute(Item
, 'GUID')
970 self
.Filename
= XmlElement(Item
, 'Filename')
971 self
.CommonDefines
.FromXml(Item
, Key
)
972 FeatureFlag
= ConvertNOTEQToNE(self
.CommonDefines
.FeatureFlag
)
973 Filename
= FileNameObject()
977 if self
.FileType
== 'UEFI_IMAGE':
978 self
.FileType
= 'PE32'
980 Filename
.SetGuidValue(Guid
)
981 Filename
.SetFileType(self
.FileType
)
982 Filename
.SetFilename(self
.Filename
)
983 Filename
.SetSupArchList(self
.CommonDefines
.SupArchList
)
984 Filename
.SetFeatureFlag(FeatureFlag
)
988 def ToXml(self
, Filename
, Key
):
991 AttributeList
= [['SupArchList', \
992 GetStringOfList(Filename
.GetSupArchList())],
993 ['FileType', Filename
.GetFileType()],
994 ['FeatureFlag', ConvertNEToNOTEQ(Filename
.GetFeatureFlag())],
995 ['GUID', Filename
.GetGuidValue()]
997 Root
= CreateXmlElement('%s' % Key
, Filename
.GetFilename(), [], AttributeList
)
1002 return "FileType = %s Filename = %s %s" \
1003 % (self
.FileType
, self
.Filename
, self
.CommonDefines
)