2 # This file is used to parse a xml file of .PKG file
4 # Copyright (c) 2008, Intel Corporation
5 # All rights reserved. This program and the accompanying materials
6 # are licensed and made available under the terms and conditions of the BSD License
7 # which accompanies this distribution. The full text of the license may be found at
8 # http://opensource.org/licenses/bsd-license.php
10 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
17 from xml
.dom
import minidom
18 from XmlRoutines
import *
19 from CommonDataClass
.DistributionPackageClass
import *
20 from CommonDataClass
.PackageClass
import *
21 from CommonDataClass
.ModuleClass
import *
22 from Common
.String
import GetStringOfList
27 def GetHelpTextList(HelpText
):
30 HelpTextObj
= HelpTextClass()
31 HelpTextObj
.Lang
= HT
.Lang
32 HelpTextObj
.String
= HT
.HelpText
33 HelpTextList
.append(HelpTextObj
)
37 class HeaderXml(object):
48 def FromXml(self
, Item
, Key
):
49 self
.Name
= XmlElement(Item
, '%s/Name' % Key
)
50 self
.BaseName
= XmlAttribute(XmlNode(Item
, '%s/Name' % Key
), 'BaseName')
51 self
.GUID
= XmlElement(Item
, '%s/GUID' % Key
)
52 self
.Version
= XmlAttribute(XmlNode(Item
, '%s/GUID' % Key
), 'Version')
53 self
.Copyright
= XmlElement(Item
, '%s/Copyright' % Key
)
54 self
.License
= XmlElement(Item
, '%s/License' % Key
)
55 self
.Abstract
= XmlElement(Item
, '%s/Abstract' % Key
)
56 self
.Description
= XmlElement(Item
, '%s/Description' % Key
)
58 ModuleHeader
= ModuleHeaderClass()
59 ModuleHeader
.Name
= self
.Name
60 ModuleHeader
.BaseName
= self
.BaseName
61 ModuleHeader
.Guid
= self
.GUID
62 ModuleHeader
.Version
= self
.Version
63 ModuleHeader
.Copyright
= self
.Copyright
64 ModuleHeader
.License
= self
.License
65 ModuleHeader
.Abstract
= self
.Abstract
66 ModuleHeader
.Description
= self
.Description
70 def ToXml(self
, Header
, Key
):
71 Element1
= CreateXmlElement('Name', Header
.Name
, [], [['BaseName', Header
.BaseName
]])
72 Element2
= CreateXmlElement('GUID', Header
.Guid
, [], [['Version', Header
.Version
]])
76 ['Abstract', Header
.Abstract
],
77 ['Copyright', Header
.Copyright
],
78 ['License', Header
.License
],
79 ['Description', Header
.Description
],
81 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, AttributeList
)
86 return "Name = %s BaseName = %s GUID = %s Version = %s Copyright = %s License = %s Abstract = %s Description = %s" \
87 % (self
.Name
, self
.BaseName
, self
.GUID
, self
.Version
, self
.Copyright
, self
.License
, self
.Abstract
, self
.Description
)
89 # DistributionPackageHeaderXml
90 class DistributionPackageHeaderXml(object):
92 self
.Header
= HeaderXml()
98 self
.XmlSpecification
= ''
100 def FromXml(self
, Item
, Key
):
101 self
.ReadOnly
= XmlAttribute(XmlNode(Item
, '%s' % Key
), 'ReadOnly')
102 self
.RePackage
= XmlAttribute(XmlNode(Item
, '%s' % Key
), 'RePackage')
103 self
.Vendor
= XmlElement(Item
, '%s/Vendor' % Key
)
104 self
.Date
= XmlElement(Item
, '%s/Date' % Key
)
105 self
.Signature
= XmlElement(Item
, '%s/Signature' % Key
)
106 self
.XmlSpecification
= XmlElement(Item
, '%s/XmlSpecification' % Key
)
107 self
.Header
.FromXml(Item
, Key
)
109 DistributionPackageHeader
= DistributionPackageHeaderClass()
110 DistributionPackageHeader
.ReadOnly
= self
.ReadOnly
111 DistributionPackageHeader
.RePackage
= self
.RePackage
112 DistributionPackageHeader
.Name
= self
.Header
.Name
113 DistributionPackageHeader
.BaseName
= self
.Header
.BaseName
114 DistributionPackageHeader
.Guid
= self
.Header
.GUID
115 DistributionPackageHeader
.Version
= self
.Header
.Version
116 DistributionPackageHeader
.Vendor
= self
.Vendor
117 DistributionPackageHeader
.Date
= self
.Date
118 DistributionPackageHeader
.Copyright
= self
.Header
.Copyright
119 DistributionPackageHeader
.License
= self
.Header
.License
120 DistributionPackageHeader
.Abstract
= self
.Header
.Abstract
121 DistributionPackageHeader
.Description
= self
.Header
.Description
122 DistributionPackageHeader
.Signature
= self
.Signature
123 DistributionPackageHeader
.XmlSpecification
= self
.XmlSpecification
125 return DistributionPackageHeader
127 def ToXml(self
, DistributionPackageHeader
, Key
):
128 Element1
= CreateXmlElement('Name', DistributionPackageHeader
.Name
, [], [['BaseName', DistributionPackageHeader
.BaseName
]])
129 Element2
= CreateXmlElement('GUID', DistributionPackageHeader
.Guid
, [], [['Version', DistributionPackageHeader
.Version
]])
130 AttributeList
= [['ReadOnly', str(DistributionPackageHeader
.ReadOnly
)], ['RePackage', str(DistributionPackageHeader
.RePackage
)]]
131 NodeList
= [Element1
,
133 ['Vendor', DistributionPackageHeader
.Vendor
],
134 ['Date', DistributionPackageHeader
.Date
],
135 ['Copyright', DistributionPackageHeader
.Copyright
],
136 ['License', DistributionPackageHeader
.License
],
137 ['Abstract', DistributionPackageHeader
.Abstract
],
138 ['Description', DistributionPackageHeader
.Description
],
139 ['Signature', DistributionPackageHeader
.Signature
],
140 ['XmlSpecification', DistributionPackageHeader
.XmlSpecification
],
142 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, AttributeList
)
147 return "ReadOnly = %s RePackage = %s Vendor = %s Date = %s Signature = %s XmlSpecification = %s %s" \
148 % (self
.ReadOnly
, self
.RePackage
, self
.Vendor
, self
.Date
, self
.Signature
, self
.XmlSpecification
, self
.Header
)
151 class PackageHeaderXml(object):
153 self
.Header
= HeaderXml()
154 self
.PackagePath
= ''
156 def FromXml(self
, Item
, Key
):
157 self
.PackagePath
= XmlElement(Item
, '%s/PackagePath' % Key
)
158 self
.Header
.FromXml(Item
, Key
)
160 PackageHeader
= PackageHeaderClass()
161 PackageHeader
.Name
= self
.Header
.Name
162 PackageHeader
.BaseName
= self
.Header
.BaseName
163 PackageHeader
.Guid
= self
.Header
.GUID
164 PackageHeader
.Version
= self
.Header
.Version
165 PackageHeader
.Copyright
= self
.Header
.Copyright
166 PackageHeader
.License
= self
.Header
.License
167 PackageHeader
.Abstract
= self
.Header
.Abstract
168 PackageHeader
.Description
= self
.Header
.Description
169 PackageHeader
.CombinePath
= self
.PackagePath
173 def ToXml(self
, PackageHeader
, Key
):
174 Element1
= CreateXmlElement('Name', PackageHeader
.Name
, [], [['BaseName', PackageHeader
.BaseName
]])
175 Element2
= CreateXmlElement('GUID', PackageHeader
.Guid
, [], [['Version', PackageHeader
.Version
]])
177 NodeList
= [Element1
,
179 ['Copyright', PackageHeader
.Copyright
],
180 ['License', PackageHeader
.License
],
181 ['Abstract', PackageHeader
.Abstract
],
182 ['Description', PackageHeader
.Description
],
183 ['PackagePath', PackageHeader
.CombinePath
],
185 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, AttributeList
)
190 return "PackagePath = %s %s" \
191 % (self
.PackagePath
, self
.Header
)
194 class ClonedFromXml(object):
199 def FromXml(self
, Item
, Key
):
200 self
.GUID
= XmlElement(Item
, '%s/GUID' % Key
)
201 self
.Version
= XmlAttribute(XmlNode(Item
, '%s/GUID' % Key
), 'Version')
203 if self
.GUID
== '' and self
.Version
== '':
206 ClonedFrom
= ClonedRecordClass()
207 ClonedFrom
.PackageGuid
= self
.GUID
208 ClonedFrom
.PackageVersion
= self
.Version
212 def ToXml(self
, ClonedFrom
, Key
):
213 Root
= minidom
.Document()
214 Element1
= CreateXmlElement('GUID', ClonedFrom
.PackageGuid
, [], [['Version', ClonedFrom
.PackageVersion
]])
216 NodeList
= [Element1
]
217 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, AttributeList
)
222 return "GUID = %s Version = %s" % (self
.GUID
, self
.Version
)
225 class CommonDefinesXml(object):
228 self
.SupArchList
= ''
230 self
.FeatureFlag
= ''
232 def FromXml(self
, Item
, Key
):
233 self
.Usage
= XmlAttribute(Item
, 'Usage')
234 self
.SupArchList
= XmlAttribute(Item
, 'SupArchList')
235 self
.SupModList
= XmlAttribute(Item
, 'SupModList')
236 self
.FeatureFlag
= XmlAttribute(Item
, 'FeatureFlag')
242 return "Usage = %s SupArchList = %s SupModList = %s FeatureFlag = %s" % (self
.Usage
, self
.SupArchList
, self
.SupModList
, self
.FeatureFlag
)
245 class HelpTextXml(object):
250 def FromXml(self
, Item
, Key
):
251 self
.HelpText
= XmlElement(Item
, 'HelpText')
252 self
.Lang
= XmlAttribute(Item
, 'Lang')
254 def ToXml(self
, HelpText
, Key
= 'HelpText'):
255 return CreateXmlElement('%s' % Key
, HelpText
.String
, [], [['Lang', HelpText
.Lang
]])
258 return "HelpText = %s Lang = %s" % (self
.HelpText
, self
.Lang
)
261 class LibraryClassXml(object):
265 self
.RecommendedInstanceGuid
= ''
266 self
.RecommendedInstanceVersion
= ''
267 self
.CommonDefines
= CommonDefinesXml()
270 def FromXml(self
, Item
, Key
):
271 self
.Keyword
= XmlAttribute(XmlNode(Item
, '%s' % Key
), 'Keyword')
272 if self
.Keyword
== '':
273 self
.Keyword
= XmlElement(Item
, '%s/Keyword' % Key
)
274 self
.HeaderFile
= XmlElement(Item
, '%s/HeaderFile' % Key
)
275 self
.RecommendedInstanceGuid
= XmlElement(Item
, '%s/RecommendedInstance/GUID' % Key
)
276 self
.RecommendedInstanceVersion
= XmlAttribute(XmlNode(Item
, '%s/RecommendedInstance/GUID' % Key
), 'Version')
277 self
.CommonDefines
.FromXml(XmlNode(Item
, '%s' % Key
), Key
)
278 for HelpTextItem
in XmlList(Item
, '%s/HelpText' % Key
):
279 HelpTextObj
= HelpTextXml()
280 HelpTextObj
.FromXml(HelpTextItem
, '%s/HelpText' % Key
)
281 self
.HelpText
.append(HelpTextObj
)
283 LibraryClass
= LibraryClassClass()
284 LibraryClass
.LibraryClass
= self
.Keyword
285 LibraryClass
.IncludeHeader
= self
.HeaderFile
286 LibraryClass
.SupArchList
= self
.CommonDefines
.SupArchList
287 LibraryClass
.SupModuleList
= self
.CommonDefines
.SupModList
288 LibraryClass
.RecommendedInstanceGuid
= self
.RecommendedInstanceGuid
289 LibraryClass
.RecommendedInstanceVersion
= self
.RecommendedInstanceVersion
290 LibraryClass
.HelpTextList
= GetHelpTextList(self
.HelpText
)
294 def ToXml(self
, LibraryClass
, Key
):
295 Element1
= CreateXmlElement('GUID', LibraryClass
.RecommendedInstanceGuid
, [], [['Version', LibraryClass
.RecommendedInstanceVersion
]])
296 Element2
= CreateXmlElement('RecommendedInstance', '', [Element1
], [])
297 AttributeList
= [['Keyword', LibraryClass
.LibraryClass
],
298 ['SupArchList', GetStringOfList(LibraryClass
.SupArchList
)],
299 ['SupModList', GetStringOfList(LibraryClass
.SupModuleList
)]
301 NodeList
= [['HeaderFile', LibraryClass
.IncludeHeader
],
304 for Item
in LibraryClass
.HelpTextList
:
306 NodeList
.append(Tmp
.ToXml(Item
))
307 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, AttributeList
)
312 Str
= "Keyword = %s HeaderFile = %s RecommendedInstanceGuid = %s RecommendedInstanceVersion = %s %s" \
313 % (self
.Keyword
, self
.HeaderFile
, self
.RecommendedInstanceGuid
, self
.RecommendedInstanceVersion
, \
315 for Item
in self
.HelpText
:
316 Str
= Str
+ "\n\t" + str(Item
)
319 # IndustryStandardHeaderXml
320 class IndustryStandardHeaderXml(object):
325 def FromXml(self
, Item
, Key
):
326 self
.HeaderFile
= XmlElement(Item
, '%s/HeaderFile' % Key
)
327 for HelpTextItem
in XmlList(Item
, '%s/HelpText' % Key
):
328 HelpTextObj
= HelpTextXml()
329 HelpTextObj
.FromXml(HelpTextItem
, '%s/HelpText' % Key
)
330 self
.HelpText
.append(HelpTextObj
)
332 Include
= IncludeClass()
333 Include
.FilePath
= self
.HeaderFile
334 Include
.HelpTextList
= GetHelpTextList(self
.HelpText
)
338 def ToXml(self
, IndustryStandardHeader
, Key
):
340 NodeList
= [['HeaderFile', IndustryStandardHeader
.FilePath
]]
341 for Item
in IndustryStandardHeader
.HelpTextList
:
343 NodeList
.append(Tmp
.ToXml(Item
))
344 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, AttributeList
)
349 Str
= "HeaderFile = %s" % (self
.HeaderFile
)
350 for Item
in self
.HelpText
:
351 Str
= Str
+ "\n\t" + str(Item
)
354 # PackageIncludeHeaderXml
355 class PackageIncludeHeaderXml(object):
358 self
.CommonDefines
= CommonDefinesXml()
361 def FromXml(self
, Item
, Key
):
362 self
.HeaderFile
= XmlElement(Item
, '%s/HeaderFile' % Key
)
363 self
.CommonDefines
.FromXml(XmlNode(Item
, '%s/HeaderFile' % Key
), Key
)
364 for HelpTextItem
in XmlList(Item
, '%s/HelpText' % Key
):
365 HelpTextObj
= HelpTextXml()
366 HelpTextObj
.FromXml(HelpTextItem
, '%s/HelpText' % Key
)
367 self
.HelpText
.append(HelpTextObj
)
369 Include
= IncludeClass()
370 Include
.FilePath
= self
.HeaderFile
371 Include
.SupArchList
= self
.CommonDefines
.SupArchList
372 Include
.SupModuleList
= self
.CommonDefines
.SupModList
373 Include
.HelpTextList
= GetHelpTextList(self
.HelpText
)
377 def ToXml(self
, PackageIncludeHeader
, Key
):
378 AttributeList
= [['SupArchList', PackageIncludeHeader
.SupArchList
],
379 ['SupModList', PackageIncludeHeader
.SupModuleList
]
381 NodeList
= [['HeaderFile', PackageIncludeHeader
.FilePath
]]
382 for Item
in PackageIncludeHeader
.HelpTextList
:
384 NodeList
.append(Tmp
.ToXml(Item
))
385 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, AttributeList
)
390 Str
= "HeaderFile = %s\n\t%s" % (self
.HeaderFile
, self
.CommonDefines
)
391 for Item
in self
.HelpText
:
392 Str
= Str
+ "\n\t" + str(Item
)
396 class GuidProtocolPpiXml(object):
403 self
.CommonDefines
= CommonDefinesXml()
406 def FromXml(self
, Item
, Key
):
407 self
.UiName
= XmlAttribute(XmlNode(Item
, '%s' % Key
), 'UiName')
408 self
.GuidTypes
= XmlAttribute(XmlNode(Item
, '%s' % Key
), 'GuidTypes')
409 self
.GuidType
= XmlAttribute(XmlNode(Item
, '%s' % Key
), 'GuidType')
410 self
.Notify
= XmlAttribute(XmlNode(Item
, '%s' % Key
), 'Notify')
411 self
.CName
= XmlElement(Item
, '%s/CName' % Key
)
412 self
.GuidValue
= XmlElement(Item
, '%s/GuidValue' % Key
)
413 self
.VariableName
= XmlElement(Item
, '%s/VariableName' % Key
)
414 self
.CommonDefines
.FromXml(XmlNode(Item
, '%s' % Key
), Key
)
415 for HelpTextItem
in XmlList(Item
, '%s/HelpText' % Key
):
416 HelpTextObj
= HelpTextXml()
417 HelpTextObj
.FromXml(HelpTextItem
, '%s/HelpText' % Key
)
418 self
.HelpText
.append(HelpTextObj
)
420 GuidProtocolPpi
= GuidProtocolPpiCommonClass()
421 GuidProtocolPpi
.Name
= self
.UiName
422 GuidProtocolPpi
.CName
= self
.CName
423 GuidProtocolPpi
.Guid
= self
.GuidValue
424 GuidProtocolPpi
.VariableName
= self
.VariableName
425 GuidProtocolPpi
.Notify
= self
.Notify
426 GuidProtocolPpi
.Usage
= self
.CommonDefines
.Usage
427 GuidProtocolPpi
.FeatureFlag
= self
.CommonDefines
.FeatureFlag
428 GuidProtocolPpi
.SupArchList
= self
.CommonDefines
.SupArchList
429 GuidProtocolPpi
.SupModuleList
= self
.CommonDefines
.SupModList
430 GuidProtocolPpi
.GuidTypeLists
= self
.GuidTypes
431 GuidProtocolPpi
.GuidTypeList
= self
.GuidType
432 GuidProtocolPpi
.HelpTextList
= GetHelpTextList(self
.HelpText
)
434 return GuidProtocolPpi
436 def ToXml(self
, GuidProtocolPpi
, Key
):
437 AttributeList
= [['Usage', GetStringOfList(GuidProtocolPpi
.Usage
)],
438 ['UiName', GuidProtocolPpi
.Name
],
439 ['GuidTypes', GetStringOfList(GuidProtocolPpi
.GuidTypeLists
)],
440 ['GuidType', GetStringOfList(GuidProtocolPpi
.GuidTypeList
)],
441 ['Notify', str(GuidProtocolPpi
.Notify
)],
442 ['SupArchList', GetStringOfList(GuidProtocolPpi
.SupArchList
)],
443 ['SupModList', GetStringOfList(GuidProtocolPpi
.SupModuleList
)],
444 ['FeatureFlag', GuidProtocolPpi
.FeatureFlag
]
446 NodeList
= [['CName', GuidProtocolPpi
.CName
],
447 ['GuidValue', GuidProtocolPpi
.Guid
],
448 ['VariableName', GuidProtocolPpi
.VariableName
]
450 for Item
in GuidProtocolPpi
.HelpTextList
:
452 NodeList
.append(Tmp
.ToXml(Item
))
453 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, AttributeList
)
458 Str
= "UiName = %s Notify = %s GuidTypes = %s CName = %s GuidValue = %s %s" \
459 % (self
.UiName
, self
.Notify
, self
.GuidTypes
, self
.CName
, self
.GuidValue
, self
.CommonDefines
)
460 for Item
in self
.HelpText
:
461 Str
= Str
+ "\n\t" + str(Item
)
465 class PcdErrorXml(object):
467 self
.ValidValueList
= ''
468 self
.ValidValueListLang
= ''
469 self
.ValidValueRange
= ''
471 self
.ErrorNumber
= ''
472 self
.ErrorMessage
= []
474 def FromXml(self
, Item
, Key
):
475 self
.ValidValueList
= XmlElement(Item
, '%s/ValidValueList' % Key
)
476 self
.ValidValueListLang
= XmlAttribute(XmlNode(Item
, '%s/ValidValueList' % Key
), 'Lang')
477 self
.ValidValueRange
= XmlElement(Item
, '%s/ValidValueRange' % Key
)
478 self
.Expression
= XmlElement(Item
, '%s/Expression' % Key
)
479 self
.ErrorNumber
= XmlElement(Item
, '%s/ErrorNumber' % Key
)
480 for ErrMsg
in XmlList(Item
, '%s/ErrorMessage' % Key
):
481 ErrorMessageString
= XmlElement(ErrMsg
, 'ErrorMessage')
482 ErrorMessageLang
= XmlAttribute(XmlNode(ErrMsg
, 'ErrorMessage'), 'Lang')
483 self
.ErrorMessage
.append((ErrorMessageLang
, ErrorMessageString
))
485 Error
= PcdErrorClass()
486 Error
.ValidValueList
= self
.ValidValueList
487 Error
.ValidValueListLang
= self
.ValidValueListLang
488 Error
.ValidValueRange
= self
.ValidValueRange
489 Error
.Expression
= self
.Expression
490 Error
.ErrorNumber
= self
.ErrorNumber
491 Error
.ErrorMessage
= self
.ErrorMessage
495 def ToXml(self
, PcdError
, Key
):
497 Element1
= CreateXmlElement('ValidValueList', PcdError
.ValidValueList
, [], [['Lang', PcdError
.ValidValueListLang
]])
498 NodeList
= [Element1
,
499 ['ValidValueRange', PcdError
.ValidValueRange
],
500 ['Expression', PcdError
.Expression
],
501 ['ErrorNumber', PcdError
.ErrorNumber
],
503 for Item
in PcdError
.ErrorMessage
:
504 Element
= CreateXmlElement('ErrorMessage', Item
[1], [], [['Lang', Item
[0]]])
505 NodeList
.append(Element
)
506 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, AttributeList
)
511 return "ValidValueList = %s ValidValueListLang = %s ValidValueRange = %s Expression = %s ErrorNumber = %s %s" \
512 % (self
.ValidValueList
, self
.ValidValueListLang
, self
.ValidValueRange
, self
.Expression
, self
.ErrorNumber
, self
.ErrorMessage
)
515 class PcdEntryXml(object):
517 self
.PcdItemType
= ''
519 self
.TokenSpaceGuidCName
= ''
520 self
.TokenSpaceGuidValue
= ''
526 self
.DefaultValue
= ''
527 self
.MaxDatumSize
= ''
530 self
.CommonDefines
= CommonDefinesXml()
534 def FromXml(self
, Item
, Key
):
535 self
.PcdItemType
= XmlAttribute(XmlNode(Item
, '%s' % Key
), 'PcdItemType')
536 self
.PcdUsage
= XmlAttribute(XmlNode(Item
, '%s' % Key
), 'PcdUsage')
537 self
.TokenSpaceGuidCName
= XmlElement(Item
, '%s/TokenSpaceGuidCName' % Key
)
538 self
.TokenSpaceGuidValue
= XmlElement(Item
, '%s/TokenSpaceGuidValue' % Key
)
539 self
.Token
= XmlElement(Item
, '%s/Token' % Key
)
540 self
.CName
= XmlElement(Item
, '%s/CName' % Key
)
541 self
.PcdCName
= XmlElement(Item
, '%s/PcdCName' % Key
)
542 self
.DatumType
= XmlElement(Item
, '%s/DatumType' % Key
)
543 self
.ValidUsage
= XmlElement(Item
, '%s/ValidUsage' % Key
)
544 self
.DefaultValue
= XmlElement(Item
, '%s/DefaultValue' % Key
)
545 self
.MaxDatumSize
= XmlElement(Item
, '%s/MaxDatumSize' % Key
)
546 self
.Value
= XmlElement(Item
, '%s/Value' % Key
)
547 self
.Offset
= XmlElement(Item
, '%s/Offset' % Key
)
548 self
.CommonDefines
.FromXml(XmlNode(Item
, '%s' % Key
), Key
)
549 for HelpTextItem
in XmlList(Item
, '%s/HelpText' % Key
):
550 HelpTextObj
= HelpTextXml()
551 HelpTextObj
.FromXml(HelpTextItem
, '%s/HelpText' % Key
)
552 self
.HelpText
.append(HelpTextObj
)
553 for PcdErrorItem
in XmlList(Item
, '%s/PcdError' % Key
):
554 PcdErrorObj
= PcdErrorXml()
555 PcdErrorObj
.FromXml(PcdErrorItem
, 'PcdError')
556 self
.PcdError
.append(PcdErrorObj
)
558 PcdEntry
= PcdClass()
559 PcdEntry
.SupArchList
= self
.CommonDefines
.SupArchList
560 PcdEntry
.SupModuleList
= self
.CommonDefines
.SupModList
561 PcdEntry
.TokenSpaceGuidCName
= self
.TokenSpaceGuidCName
562 PcdEntry
.TokenSpaceGuidValue
= self
.TokenSpaceGuidValue
563 PcdEntry
.Token
= self
.Token
564 PcdEntry
.CName
= self
.CName
565 PcdEntry
.PcdCName
= self
.PcdCName
566 PcdEntry
.DatumType
= self
.DatumType
567 PcdEntry
.ValidUsage
= self
.ValidUsage
568 PcdEntry
.PcdUsage
= self
.PcdUsage
569 PcdEntry
.Usage
= self
.CommonDefines
.Usage
570 PcdEntry
.DefaultValue
= self
.DefaultValue
571 PcdEntry
.Value
= self
.Value
572 PcdEntry
.Offset
= self
.Offset
573 PcdEntry
.MaxDatumSize
= self
.MaxDatumSize
574 PcdEntry
.FeatureFlag
= self
.CommonDefines
.FeatureFlag
575 PcdEntry
.PcdItemType
= self
.PcdItemType
576 PcdEntry
.HelpTextList
= GetHelpTextList(self
.HelpText
)
577 PcdEntry
.PcdErrors
= self
.PcdError
581 def ToXml(self
, PcdEntry
, Key
):
582 AttributeList
= [['SupArchList', GetStringOfList(PcdEntry
.SupArchList
)],
583 ['PcdUsage', PcdEntry
.PcdUsage
],
584 ['PcdItemType', PcdEntry
.PcdItemType
],
585 ['FeatureFlag', PcdEntry
.FeatureFlag
],
586 ['SupModList', GetStringOfList(PcdEntry
.SupModuleList
)]
588 NodeList
= [['TokenSpaceGuidCName', PcdEntry
.TokenSpaceGuidCName
],
589 ['TokenSpaceGuidValue', PcdEntry
.TokenSpaceGuidValue
],
590 ['Token', PcdEntry
.Token
],
591 ['CName', PcdEntry
.CName
],
592 ['PcdCName', PcdEntry
.PcdCName
],
593 ['DatumType', PcdEntry
.DatumType
],
594 ['ValidUsage', GetStringOfList(PcdEntry
.ValidUsage
)],
595 ['DefaultValue', PcdEntry
.DefaultValue
],
596 ['Value', PcdEntry
.Value
],
597 ['Offset', PcdEntry
.Offset
],
598 ['MaxDatumSize', PcdEntry
.MaxDatumSize
],
600 for Item
in PcdEntry
.HelpTextList
:
602 NodeList
.append(Tmp
.ToXml(Item
, 'HelpText'))
603 for Item
in PcdEntry
.PcdErrors
:
605 NodeList
.append(Tmp
.ToXml(Item
, 'PcdError'))
607 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, AttributeList
)
612 Str
= "PcdItemType = %s PcdUsage = %s TokenSpaceGuidCName = %s TokenSpaceGuidValue = %s Token = %s CName = %s PcdCName = %s DatumType = %s ValidUsage = %s DefaultValue = %s MaxDatumSize = %s Value = %s Offset = %s %s" \
613 % (self
.PcdItemType
, self
.PcdUsage
, self
.TokenSpaceGuidCName
, self
.TokenSpaceGuidValue
, self
.Token
, self
.CName
, self
.PcdCName
, self
.DatumType
, self
.ValidUsage
, self
.DefaultValue
, self
.MaxDatumSize
, self
.Value
, self
.Offset
, self
.CommonDefines
)
614 for Item
in self
.HelpText
:
615 Str
= Str
+ "\n\t" + str(Item
)
616 for Item
in self
.PcdError
:
617 Str
= Str
+ "\n\tPcdError:" + str(Item
)
621 class PcdCheckXml(object):
625 def FromXml(self
, Item
, Key
):
626 self
.PcdCheck
= XmlElement(Item
, 'PcdCheck')
630 def ToXml(self
, PcdCheck
, Key
):
631 Root
= CreateXmlElement('%s' % Key
, PcdCheck
, [], [])
635 return "PcdCheck = %s" % (self
.PcdCheck
)
637 # MiscellaneousFileXml
638 class MiscellaneousFileXml(object):
640 self
.Header
= HeaderXml()
643 def FromXml(self
, Item
, Key
):
644 self
.Header
.FromXml(Item
, Key
)
645 NewItem
= XmlNode(Item
, '%s/Header' % Key
)
646 self
.Header
.FromXml(NewItem
, 'Header')
648 for SubItem
in XmlList(Item
, '%s/Filename' % Key
):
649 Filename
= XmlElement(SubItem
, '%s/Filename' % Key
)
650 Executable
= XmlAttribute(XmlNode(SubItem
, '%s/Filename' % Key
), 'Executable')
651 self
.Files
.append([Filename
, Executable
])
653 MiscFile
= MiscFileClass()
654 MiscFile
.Copyright
= self
.Header
.Copyright
655 MiscFile
.License
= self
.Header
.License
656 MiscFile
.Abstract
= self
.Header
.Abstract
657 MiscFile
.Description
= self
.Header
.Description
658 for File
in self
.Files
:
659 FileObj
= FileClass()
660 FileObj
.Filename
= File
[0]
661 FileObj
.Executable
= File
[1]
662 MiscFile
.Files
.append(FileObj
)
666 def FromXml2(self
, Item
, Key
):
667 NewItem
= XmlNode(Item
, '%s/Header' % Key
)
668 self
.Header
.FromXml(NewItem
, 'Header')
670 for SubItem
in XmlList(Item
, '%s/Filename' % Key
):
671 Filename
= XmlElement(SubItem
, '%s/Filename' % Key
)
672 Executable
= XmlAttribute(XmlNode(SubItem
, '%s/Filename' % Key
), 'Executable')
673 self
.Files
.append([Filename
, Executable
])
675 MiscFile
= MiscFileClass()
676 MiscFile
.Name
= self
.Header
.Name
677 MiscFile
.Copyright
= self
.Header
.Copyright
678 MiscFile
.License
= self
.Header
.License
679 MiscFile
.Abstract
= self
.Header
.Abstract
680 MiscFile
.Description
= self
.Header
.Description
681 for File
in self
.Files
:
682 FileObj
= FileClass()
683 FileObj
.Filename
= File
[0]
684 FileObj
.Executable
= File
[1]
685 MiscFile
.Files
.append(FileObj
)
690 def ToXml(self
, MiscFile
, Key
):
692 NodeList
= [['Copyright', MiscFile
.Copyright
],
693 ['License', MiscFile
.License
],
694 ['Abstract', MiscFile
.Abstract
],
695 ['Description', MiscFile
.Description
],
698 for File
in MiscFile
.Files
:
699 NodeList
.append(CreateXmlElement('Filename', File
.Filename
, [], [['Executable', File
.Executable
]]))
700 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, [])
704 def ToXml2(self
, MiscFile
, Key
):
706 NodeList
= [['Name', MiscFile
.Name
],
707 ['Copyright', MiscFile
.Copyright
],
708 ['License', MiscFile
.License
],
709 ['Abstract', MiscFile
.Abstract
],
710 ['Description', MiscFile
.Description
],
712 HeaderNode
= CreateXmlElement('Header', '', NodeList
, [])
713 NodeList
= [HeaderNode
]
715 for File
in MiscFile
.Files
:
716 NodeList
.append(CreateXmlElement('Filename', File
.Filename
, [], [['Executable', File
.Executable
]]))
717 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, [])
722 Str
= str(self
.Header
)
723 for Item
in self
.Files
:
724 Str
= Str
+ '\n\tFilename:' + str(Item
)
728 class UserExtensionsXml(object):
733 self
.BuildOptions
= []
735 def FromXml(self
, Item
, Key
):
736 self
.UserId
= XmlAttribute(XmlNode(Item
, '%s' % Key
), 'UserId')
737 self
.Identifier
= XmlAttribute(XmlNode(Item
, '%s' % Key
), 'Identifier')
738 for SubItem
in XmlList(Item
, '%s/Define' % Key
):
739 self
.Defines
.append(XmlElement(SubItem
, '%s/Define' % Key
))
740 for SubItem
in XmlList(Item
, '%s/BuildOption' % Key
):
741 self
.BuildOptions
.append(XmlElement(SubItem
, '%s/BuildOption' % Key
))
743 UserExtension
= UserExtensionsClass()
744 UserExtension
.UserID
= self
.UserId
745 UserExtension
.Identifier
= self
.Identifier
746 UserExtension
.Defines
= self
.Defines
747 UserExtension
.BuildOptions
= self
.BuildOptions
751 def ToXml(self
, UserExtension
, Key
):
752 AttributeList
= [['UserId', str(UserExtension
.UserID
)],
753 ['Identifier', str(UserExtension
.Identifier
)]
756 for Item
in UserExtension
.Defines
:
757 NodeList
.append(['Define', Item
])
758 for Item
in UserExtension
.BuildOptions
:
759 NodeList
.append(['BuildOption', Item
])
760 Root
= CreateXmlElement('%s' % Key
, UserExtension
.Content
, NodeList
, AttributeList
)
765 Str
= "UserId = %s Identifier = %s" % (self
.UserId
, self
.Identifier
)
766 Str
= Str
+ '\n\tDefines:' + str(self
.Defines
)
767 Str
= Str
+ '\n\tBuildOptions:' + str(self
.BuildOptions
)
771 class BootModeXml(object):
773 self
.SupportedBootModes
= ''
774 self
.CommonDefines
= CommonDefinesXml()
777 def FromXml(self
, Item
, Key
):
778 self
.SupportedBootModes
= XmlElement(Item
, '%s/SupportedBootModes' % Key
)
779 self
.CommonDefines
.FromXml(Item
, Key
)
780 for HelpTextItem
in XmlList(Item
, '%s/HelpText' % Key
):
781 HelpTextObj
= HelpTextXml()
782 HelpTextObj
.FromXml(HelpTextItem
, '%s/HelpText' % Key
)
783 self
.HelpText
.append(HelpTextObj
)
785 BootMode
= ModuleBootModeClass()
786 BootMode
.Name
= self
.SupportedBootModes
787 BootMode
.SupArchList
= self
.CommonDefines
.SupArchList
788 BootMode
.Usage
= self
.CommonDefines
.Usage
789 BootMode
.FeatureFlag
= self
.CommonDefines
.FeatureFlag
790 BootMode
.HelpTextList
= GetHelpTextList(self
.HelpText
)
794 def ToXml(self
, BootMode
, Key
):
795 AttributeList
= [['Usage', BootMode
.Usage
],
796 ['SupArchList', GetStringOfList(BootMode
.SupArchList
)],
797 ['FeatureFlag', BootMode
.FeatureFlag
],
799 NodeList
= [['SupportedBootModes', BootMode
.Name
]]
800 for Item
in BootMode
.HelpTextList
:
802 NodeList
.append(Tmp
.ToXml(Item
, 'HelpText'))
803 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, AttributeList
)
808 Str
= "SupportedBootModes = %s %s" % (self
.SupportedBootModes
, self
.CommonDefines
)
809 for Item
in self
.HelpText
:
810 Str
= Str
+ '\n\t' + str(Item
)
814 class EventXml(object):
818 self
.CommonDefines
= CommonDefinesXml()
821 def FromXml(self
, Item
, Key
):
822 self
.EventType
= XmlAttribute(XmlNode(Item
, '%s' % Key
), 'EventType')
823 self
.Name
= XmlElement(Item
, '%s' % Key
)
824 self
.CommonDefines
.FromXml(Item
, Key
)
825 for HelpTextItem
in XmlList(Item
, '%s/HelpText' % Key
):
826 HelpTextObj
= HelpTextXml()
827 HelpTextObj
.FromXml(HelpTextItem
, '%s/HelpText' % Key
)
828 self
.HelpText
.append(HelpTextObj
)
830 Event
= ModuleEventClass()
831 Event
.Type
= self
.EventType
832 Event
.GuidCName
= self
.Name
833 Event
.SupArchList
= self
.CommonDefines
.SupArchList
834 Event
.Usage
= self
.CommonDefines
.Usage
835 Event
.FeatureFlag
= self
.CommonDefines
.FeatureFlag
836 Event
.HelpTextList
= GetHelpTextList(self
.HelpText
)
840 def ToXml(self
, Event
, Key
):
841 AttributeList
= [['EventType', Event
.Type
],
842 ['Usage', Event
.Usage
],
843 ['SupArchList', GetStringOfList(Event
.SupArchList
)],
844 ['FeatureFlag', Event
.FeatureFlag
],
847 for Item
in Event
.HelpTextList
:
849 NodeList
.append(Tmp
.ToXml(Item
, 'HelpText'))
850 Root
= CreateXmlElement('%s' % Key
, Event
.GuidCName
, NodeList
, AttributeList
)
855 Str
= "EventType = %s %s" % (self
.EventType
, self
.CommonDefines
)
856 for Item
in self
.HelpText
:
857 Str
= Str
+ '\n\t' + str(Item
)
861 class HobXml(object):
865 self
.CommonDefines
= CommonDefinesXml()
868 def FromXml(self
, Item
, Key
):
869 self
.HobType
= XmlAttribute(XmlNode(Item
, '%s' % Key
), 'HobType')
870 self
.Name
= XmlElement(Item
, '%s' % Key
)
871 self
.CommonDefines
.FromXml(Item
, Key
)
872 for HelpTextItem
in XmlList(Item
, '%s/HelpText' % Key
):
873 HelpTextObj
= HelpTextXml()
874 HelpTextObj
.FromXml(HelpTextItem
, '%s/HelpText' % Key
)
875 self
.HelpText
.append(HelpTextObj
)
877 Hob
= ModuleHobClass()
878 Hob
.Type
= self
.HobType
879 Hob
.GuidCName
= self
.Name
880 Hob
.SupArchList
= self
.CommonDefines
.SupArchList
881 Hob
.Usage
= self
.CommonDefines
.Usage
882 Hob
.FeatureFlag
= self
.CommonDefines
.FeatureFlag
883 Hob
.HelpTextList
= GetHelpTextList(self
.HelpText
)
887 def ToXml(self
, Hob
, Key
):
888 AttributeList
= [['EventType', Hob
.Type
],
889 ['Usage', Hob
.Usage
],
890 ['SupArchList', GetStringOfList(Hob
.SupArchList
)],
891 ['FeatureFlag', Hob
.FeatureFlag
],
894 for Item
in Hob
.HelpTextList
:
896 NodeList
.append(Tmp
.ToXml(Item
, 'HelpText'))
897 Root
= CreateXmlElement('%s' % Key
, Hob
.GuidCName
, NodeList
, AttributeList
)
902 Str
= "HobType = %s %s" % (self
.HobType
, self
.CommonDefines
)
903 for Item
in self
.HelpText
:
904 Str
= Str
+ '\n\t' + str(Item
)
908 class ModulePropertyXml(object):
910 self
.CommonDefines
= CommonDefinesXml()
913 self
.PcdIsDriver
= ''
914 self
.UefiSpecificationVersion
= ''
915 self
.PiSpecificationVersion
= ''
916 self
.Specification
= ''
917 self
.SpecificationVersion
= ''
922 def FromXml(self
, Item
, Key
, Header
= None):
923 self
.CommonDefines
.FromXml(Item
, Key
)
924 self
.ModuleType
= XmlElement(Item
, '%s/ModuleType' % Key
)
925 self
.Path
= XmlElement(Item
, '%s/Path' % Key
)
926 self
.PcdIsDriver
= XmlElement(Item
, '%s/PcdIsDriver' % Key
)
927 self
.UefiSpecificationVersion
= XmlElement(Item
, '%s/UefiSpecificationVersion' % Key
)
928 self
.PiSpecificationVersion
= XmlElement(Item
, '%s/PiSpecificationVersion' % Key
)
929 self
.Specification
= XmlElement(Item
, '%s/Specification' % Key
)
930 self
.SpecificationVersion
= XmlAttribute(XmlNode(Item
, '%s/Specification' % Key
), 'Version')
931 for SubItem
in XmlList(Item
, '%s/BootMode' % Key
):
933 BootMode
= A
.FromXml(SubItem
, 'BootMode')
934 self
.BootModes
.append(BootMode
)
935 for SubItem
in XmlList(Item
, '%s/Event' % Key
):
937 Event
= A
.FromXml(SubItem
, 'Event')
938 self
.Events
.append(Event
)
939 for SubItem
in XmlList(Item
, '%s/HOB' % Key
):
941 Hob
= A
.FromXml(SubItem
, 'HOB')
942 self
.HOBs
.append(Hob
)
945 Header
= ModuleHeaderClass()
947 Header
.ModuleType
= self
.ModuleType
948 Header
.SupArchList
= self
.CommonDefines
.SupArchList
949 Header
.SupModuleList
= self
.CommonDefines
.SupModList
950 Header
.CombinePath
= self
.Path
951 Header
.PcdIsDriver
= self
.PcdIsDriver
952 Header
.UefiSpecificationVersion
= self
.UefiSpecificationVersion
953 Header
.PiSpecificationVersion
= self
.PiSpecificationVersion
955 return Header
, self
.BootModes
, self
.Events
, self
.HOBs
958 def ToXml(self
, Header
, BootModes
, Events
, Hobs
, Key
):
959 AttributeList
= [['SupArchList', GetStringOfList(Header
.SupArchList
)],
960 ['SupModList', GetStringOfList(Header
.SupModuleList
)],
962 NodeList
= [['ModuleType', Header
.ModuleType
],
963 ['Path', Header
.CombinePath
],
964 ['PcdIsDriver', Header
.PcdIsDriver
],
965 ['UefiSpecificationVersion', Header
.UefiSpecificationVersion
],
966 ['PiSpecificationVersion', Header
.PiSpecificationVersion
],
968 for Item
in BootModes
:
970 NodeList
.append(Tmp
.ToXml(Item
, 'BootMode'))
973 NodeList
.append(Tmp
.ToXml(Item
, 'Event'))
976 NodeList
.append(Tmp
.ToXml(Item
, 'Hob'))
977 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, AttributeList
)
982 Str
= "ModuleType = %s Path = %s PcdIsDriver = %s UefiSpecificationVersion = %s PiSpecificationVersion = %s Specification = %s SpecificationVersion = %s %s" \
983 % (self
.ModuleType
, self
.Path
, self
.PcdIsDriver
, self
.UefiSpecificationVersion
, self
.PiSpecificationVersion
, \
984 self
.Specification
, self
.SpecificationVersion
, self
.CommonDefines
)
985 for Item
in self
.BootModes
:
986 Str
= Str
+ '\n\t' + str(Item
)
987 for Item
in self
.Events
:
988 Str
= Str
+ '\n\t' + str(Item
)
989 for Item
in self
.HOBs
:
990 Str
= Str
+ '\n\t' + str(Item
)
994 class SourceFileXml(object):
997 self
.ToolChainFamily
= ''
999 self
.CommonDefines
= CommonDefinesXml()
1001 def FromXml(self
, Item
, Key
):
1002 self
.ToolChainFamily
= XmlAttribute(Item
, 'Family')
1003 self
.FileType
= XmlAttribute(Item
, 'FileType')
1004 self
.SourceFile
= XmlElement(Item
, 'Filename')
1005 self
.CommonDefines
.FromXml(Item
, Key
)
1007 SourceFile
= ModuleSourceFileClass()
1008 SourceFile
.SourceFile
= self
.SourceFile
1009 SourceFile
.FileType
= self
.FileType
1010 SourceFile
.ToolChainFamily
= self
.ToolChainFamily
1011 SourceFile
.SupArchList
= self
.CommonDefines
.SupArchList
1012 SourceFile
.FeatureFlag
= self
.CommonDefines
.FeatureFlag
1016 def ToXml(self
, SourceFile
, Key
):
1017 AttributeList
= [['SupArchList', GetStringOfList(SourceFile
.SupArchList
)],
1018 ['Family', SourceFile
.ToolChainFamily
],
1019 ['FileType', SourceFile
.FileType
],
1020 ['FeatureFlag', SourceFile
.FeatureFlag
],
1022 Root
= CreateXmlElement('%s' % Key
, SourceFile
.SourceFile
, [], AttributeList
)
1027 class FilenameXml(object):
1033 self
.Executable
= ''
1034 self
.CommonDefines
= CommonDefinesXml()
1036 def FromXml(self
, Item
, Key
):
1037 self
.OS
= XmlAttribute(Item
, 'OS')
1038 self
.Family
= XmlAttribute(Item
, 'Family')
1039 self
.FileType
= XmlAttribute(Item
, 'FileType')
1040 self
.Filename
= XmlElement(Item
, 'Filename')
1041 self
.Executable
= XmlElement(Item
, 'Executable')
1042 self
.CommonDefines
.FromXml(Item
, Key
)
1044 Filename
= FileClass()
1045 Filename
.Family
= self
.Family
1046 Filename
.FileType
= self
.FileType
1047 Filename
.Filename
= self
.Filename
1048 Filename
.Executable
= self
.Executable
1049 Filename
.SupArchList
= self
.CommonDefines
.SupArchList
1050 Filename
.FeatureFlag
= self
.CommonDefines
.FeatureFlag
1054 def ToXml(self
, Filename
, Key
):
1055 AttributeList
= [['SupArchList', GetStringOfList(Filename
.SupArchList
)],
1056 ['Family', Filename
.Family
],
1057 ['FileType', Filename
.FileType
],
1058 ['Executable', Filename
.Executable
],
1059 ['FeatureFlag', Filename
.FeatureFlag
],
1061 NodeList
= [['Filename', Filename
.Filename
],
1063 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, AttributeList
)
1068 return "OS = %s Family = %s FileType = %s Filename = %s Executable = %s %s" \
1069 % (self
.OS
, self
.Family
, self
.FileType
, self
.Filename
, self
.Executable
, self
.CommonDefines
)
1071 class BinaryFileXml(object):
1074 self
.PatchPcdValues
= []
1075 self
.PcdExValues
= []
1076 self
.LibraryInstances
= []
1077 self
.BuildFlags
= []
1079 def FromXml(self
, Item
, Key
):
1080 BinaryFile
= ModuleBinaryFileClass()
1081 for SubItem
in XmlList(Item
, '%s/Filename' % Key
):
1083 B
= A
.FromXml(SubItem
, 'Filename')
1084 BinaryFile
.Filenames
.append(B
)
1085 for SubItem
in XmlList(Item
, '%s/AsBuilt/PatchPcdValue' % Key
):
1087 B
= A
.FromXml(SubItem
, 'PatchPcdValue')
1088 BinaryFile
.PatchPcdValues
.append(B
)
1089 for SubItem
in XmlList(Item
, '%s/AsBuilt/PcdExValue' % Key
):
1091 B
= A
.FromXml(SubItem
, 'PcdExValue')
1092 BinaryFile
.PatchPcdValues
.append(B
)
1093 for SubItem
in XmlList(Item
, '%s/AsBuilt/LibraryInstances/GUID' % Key
):
1094 GUID
= XmlElement(SubItem
, 'GUID')
1095 Version
= XmlAttribute(XmlNode(SubItem
, 'GUID'), 'Version')
1096 BinaryFile
.LibraryInstances
.append([GUID
, Version
])
1097 for SubItem
in XmlList(Item
, '%s/AsBuilt/BuildFlags' % Key
):
1098 BinaryFile
.BuildFlags
.append(XmlElement(SubItem
, 'BuildFlags'))
1102 def ToXml(self
, BinaryFile
, Key
):
1104 for Item
in BinaryFile
.Filenames
:
1106 NodeList
.append(Tmp
.ToXml(Item
, 'Filename'))
1107 AsBuiltNodeList
= []
1108 for Item
in BinaryFile
.PatchPcdValues
:
1110 AsBuiltNodeList
.append(Tmp
.ToXml(Item
, 'PatchPcdValue'))
1111 for Item
in BinaryFile
.PcdExValues
:
1113 AsBuiltNodeList
.append(Tmp
.ToXml(Item
, 'PcdExValue'))
1115 for Item
in BinaryFile
.LibraryInstances
:
1116 LibNode
= CreateXmlElement('GUID', Item
[0], [], [['Version', Item
[1]]])
1117 LibNodeList
.append(LibNode
)
1119 AsBuiltNodeList
.append(CreateXmlElement('LibraryInstances', '', LibNodeList
, []))
1120 for Item
in BinaryFile
.BuildFlags
:
1121 AsBuiltNodeList
.append(CreateXmlElement('BuildFlags', Item
, [], []))
1122 Element
= CreateXmlElement('AsBuilt', '', AsBuiltNodeList
, [])
1123 NodeList
.append(Element
)
1125 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, [])
1130 Str
= "BinaryFiles:"
1131 for Item
in self
.Filenames
:
1132 Str
= Str
+ '\n\t' + str(Item
)
1133 for Item
in self
.PatchPcdValues
:
1134 Str
= Str
+ '\n\t' + str(Item
)
1135 for Item
in self
.PcdExValues
:
1136 Str
= Str
+ '\n\t' + str(Item
)
1137 for Item
in self
.LibraryInstances
:
1138 Str
= Str
+ '\n\t' + str(Item
)
1139 for Item
in self
.BuildFlags
:
1140 Str
= Str
+ '\n\t' + str(Item
)
1144 class PackageXml(object):
1146 self
.Description
= ''
1149 self
.CommonDefines
= CommonDefinesXml()
1151 def FromXml(self
, Item
, Key
):
1152 self
.Description
= XmlElement(Item
, '%s/Description' % Key
)
1153 self
.Guid
= XmlElement(Item
, '%s/GUID' % Key
)
1154 self
.Version
= XmlAttribute(XmlNode(Item
, '%s/GUID' % Key
), 'Version')
1155 self
.CommonDefines
.FromXml(XmlNode(Item
, '%s' % Key
), Key
)
1157 PackageDependency
= ModulePackageDependencyClass()
1158 PackageDependency
.FilePath
= self
.Description
1159 PackageDependency
.PackageGuid
= self
.Guid
1160 PackageDependency
.PackageVersion
= self
.Version
1161 PackageDependency
.FeatureFlag
= self
.CommonDefines
.FeatureFlag
1162 PackageDependency
.SupArchList
= self
.CommonDefines
.SupArchList
1164 return PackageDependency
1166 def ToXml(self
, PackageDependency
, Key
):
1167 AttributeList
= [['SupArchList', GetStringOfList(PackageDependency
.SupArchList
)],
1168 ['FeatureFlag', PackageDependency
.FeatureFlag
],
1170 Element1
= CreateXmlElement('GUID', PackageDependency
.PackageGuid
, [], [['Version', PackageDependency
.PackageVersion
]])
1171 NodeList
= [['Description', PackageDependency
.FilePath
],
1175 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, AttributeList
)
1180 Str
= "Description = %s Guid = %s Version = %s %s" \
1181 % (self
.Description
, self
.Guid
, self
.Version
, self
.CommonDefines
)
1185 class ExternXml(object):
1187 self
.CommonDefines
= CommonDefinesXml()
1188 self
.EntryPoint
= ''
1189 self
.UnloadImage
= ''
1190 self
.Constructor
= ''
1191 self
.Destructor
= ''
1194 def FromXml(self
, Item
, Key
):
1195 self
.CommonDefines
.FromXml(Item
, Key
)
1196 self
.EntryPoint
= XmlElement(Item
, '%s/EntryPoint' % Key
)
1197 self
.UnloadImage
= XmlElement(Item
, '%s/UnloadImage' % Key
)
1198 self
.Constructor
= XmlElement(Item
, '%s/Constructor' % Key
)
1199 self
.Destructor
= XmlElement(Item
, '%s/Destructor' % Key
)
1200 for HelpTextItem
in XmlList(Item
, '%s/HelpText' % Key
):
1201 HelpTextObj
= HelpTextXml()
1202 HelpTextObj
.FromXml(HelpTextItem
, '%s/HelpText' % Key
)
1203 self
.HelpText
.append(HelpTextObj
)
1205 Extern
= ModuleExternClass()
1206 Extern
.EntryPoint
= self
.EntryPoint
1207 Extern
.UnloadImage
= self
.UnloadImage
1208 Extern
.Constructor
= self
.Constructor
1209 Extern
.Destructor
= self
.Destructor
1210 Extern
.SupArchList
= self
.CommonDefines
.SupArchList
1211 Extern
.FeatureFlag
= self
.CommonDefines
.FeatureFlag
1212 Extern
.HelpTextList
= GetHelpTextList(self
.HelpText
)
1216 def ToXml(self
, Extern
, Key
):
1217 AttributeList
= [['SupArchList', GetStringOfList(Extern
.SupArchList
)],
1218 ['FeatureFlag', Extern
.FeatureFlag
],
1220 NodeList
= [['EntryPoint', Extern
.EntryPoint
],
1221 ['UnloadImage', Extern
.UnloadImage
],
1222 ['Constructor', Extern
.Constructor
],
1223 ['Destructor', Extern
.Destructor
],
1225 for Item
in Extern
.HelpTextList
:
1227 NodeList
.append(Tmp
.ToXml(Item
, 'HelpText'))
1229 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, AttributeList
)
1234 Str
= "EntryPoint = %s UnloadImage = %s Constructor = %s Destructor = %s %s" \
1235 % (self
.EntryPoint
, self
.UnloadImage
, self
.Constructor
, self
.Destructor
, self
.CommonDefines
)
1236 for Item
in self
.HelpText
:
1237 Str
= Str
+ '\n\t' + str(Item
)
1240 class DepexXml(object):
1242 self
.Expression
= ''
1243 #self.HelpText = HelpTextXml()
1246 def FromXml(self
, Item
, Key
):
1247 self
.Expression
= XmlElement(Item
, '%s/Expression' % Key
)
1248 for HelpTextItem
in XmlList(Item
, '%s/HelpText' % Key
):
1249 HelpTextObj
= HelpTextXml()
1250 HelpTextObj
.FromXml(HelpTextItem
, '%s/HelpText' % Key
)
1251 self
.HelpText
.append(HelpTextObj
)
1253 Depex
= ModuleDepexClass()
1254 Depex
.Depex
= self
.Expression
1255 Depex
.HelpTextList
= GetHelpTextList(self
.HelpText
)
1259 def ToXml(self
, Depex
, Key
):
1261 NodeList
= [['Expression', Depex
.Depex
],
1263 for Item
in Depex
.HelpTextList
:
1265 NodeList
.append(Tmp
.ToXml(Item
, 'HelpText'))
1267 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, AttributeList
)
1272 Str
= "Expression = %s" % (self
.Expression
)
1273 for Item
in self
.HelpText
:
1274 Str
= Str
+ '\n\t' + str(Item
)
1277 # PackageSurfaceAreaXml
1278 class PackageSurfaceAreaXml(object):
1282 def FromXml(self
, Item
, Key
):
1283 # Create a package object
1284 Package
= PackageClass()
1287 Tmp
= PackageHeaderXml()
1288 PackageHeader
= Tmp
.FromXml(XmlNode(Item
, '/PackageSurfaceArea/Header'), 'Header')
1289 Package
.PackageHeader
= PackageHeader
1292 Tmp
= ClonedFromXml()
1293 ClonedFrom
= Tmp
.FromXml(XmlNode(Item
, '/PackageSurfaceArea/ClonedFrom'), 'ClonedFrom')
1295 Package
.PackageHeader
.ClonedFrom
.append(ClonedFrom
)
1298 for SubItem
in XmlList(Item
, '/PackageSurfaceArea/LibraryClassDeclarations/LibraryClass'):
1299 Tmp
= LibraryClassXml()
1300 LibraryClass
= Tmp
.FromXml(SubItem
, 'LibraryClass')
1301 Package
.LibraryClassDeclarations
.append(LibraryClass
)
1303 # IndustryStandardHeader
1304 for SubItem
in XmlList(Item
, '/PackageSurfaceArea/IndustryStandardIncludes/IndustryStandardHeader'):
1305 Tmp
= IndustryStandardHeaderXml()
1306 Include
= Tmp
.FromXml(SubItem
, 'IndustryStandardHeader')
1307 Package
.IndustryStdHeaders
.append(Include
)
1310 for SubItem
in XmlList(Item
, '/PackageSurfaceArea/PackageIncludes/PackageHeader'):
1311 Tmp
= PackageIncludeHeaderXml()
1312 Include
= Tmp
.FromXml(SubItem
, 'PackageHeader')
1313 Package
.PackageIncludePkgHeaders
.append(Include
)
1316 for SubItem
in XmlList(Item
, '/PackageSurfaceArea/GuidDeclarations/Entry'):
1317 Tmp
= GuidProtocolPpiXml()
1318 GuidProtocolPpi
= Tmp
.FromXml(SubItem
, 'Entry')
1319 Package
.GuidDeclarations
.append(GuidProtocolPpi
)
1322 for SubItem
in XmlList(Item
, '/PackageSurfaceArea/ProtocolDeclarations/Entry'):
1323 Tmp
= GuidProtocolPpiXml()
1324 GuidProtocolPpi
= Tmp
.FromXml(SubItem
, 'Entry')
1325 Package
.ProtocolDeclarations
.append(GuidProtocolPpi
)
1328 for SubItem
in XmlList(Item
, '/PackageSurfaceArea/PpiDeclarations/Entry'):
1329 Tmp
= GuidProtocolPpiXml()
1330 GuidProtocolPpi
= Tmp
.FromXml(SubItem
, 'Entry')
1331 Package
.PpiDeclarations
.append(GuidProtocolPpi
)
1334 for SubItem
in XmlList(Item
, '/PackageSurfaceArea/PcdDeclarations/PcdEntry'):
1336 PcdEntry
= Tmp
.FromXml(SubItem
, 'PcdEntry')
1337 Package
.PcdDeclarations
.append(PcdEntry
)
1340 for SubItem
in XmlList(Item
, '/PackageSurfaceArea/PcdRelationshipChecks/PcdCheck'):
1342 PcdCheck
= Tmp
.FromXml(SubItem
, 'PcdCheck')
1343 Package
.PcdChecks
.append(PcdCheck
)
1346 Tmp
= MiscellaneousFileXml()
1347 Package
.MiscFiles
= Tmp
.FromXml(XmlNode(Item
, '/PackageSurfaceArea/MiscellaneousFiles'), 'MiscellaneousFiles')
1350 Tmp
= UserExtensionsXml()
1351 Package
.UserExtensions
= Tmp
.FromXml(XmlNode(Item
, '/PackageSurfaceArea/UserExtensions'), 'UserExtensions')
1354 for SubItem
in XmlList(Item
, '/PackageSurfaceArea/Modules/ModuleSurfaceArea'):
1355 Tmp
= ModuleSurfaceAreaXml()
1356 Module
= Tmp
.FromXml(SubItem
, 'ModuleSurfaceArea')
1357 Package
.Modules
[(Module
.ModuleHeader
.Guid
, Module
.ModuleHeader
.Version
, Module
.ModuleHeader
.CombinePath
)] = Module
1359 self
.Package
= Package
1362 def ToXml(self
, Package
):
1363 # Create PackageSurfaceArea node
1364 DomPackage
= minidom
.Document().createElement('PackageSurfaceArea')
1367 Tmp
= PackageHeaderXml()
1368 DomPackage
.appendChild(Tmp
.ToXml(Package
.PackageHeader
, 'Header'))
1371 Tmp
= ClonedFromXml()
1372 if Package
.PackageHeader
.ClonedFrom
!= []:
1373 DomPackage
.appendChild(Tmp
.ToXml(Package
.PackageHeader
.ClonedFrom
[0], 'ClonedFrom'))
1376 LibraryClassNode
= CreateXmlElement('LibraryClassDeclarations', '', [], [])
1377 for LibraryClass
in Package
.LibraryClassDeclarations
:
1378 Tmp
= LibraryClassXml()
1379 LibraryClassNode
.appendChild(Tmp
.ToXml(LibraryClass
, 'LibraryClass'))
1380 DomPackage
.appendChild(LibraryClassNode
)
1382 # IndustryStandardHeader
1383 IndustryStandardHeaderNode
= CreateXmlElement('IndustryStandardIncludes', '', [], [])
1384 for Include
in Package
.IndustryStdHeaders
:
1385 Tmp
= IndustryStandardHeaderXml()
1386 IndustryStandardHeaderNode
.appendChild(Tmp
.ToXml(Include
, 'IndustryStandardHeader'))
1387 DomPackage
.appendChild(IndustryStandardHeaderNode
)
1390 PackageIncludeHeaderNode
= CreateXmlElement('PackageIncludes', '', [], [])
1391 for Include
in Package
.PackageIncludePkgHeaders
:
1392 Tmp
= PackageIncludeHeaderXml()
1393 PackageIncludeHeaderNode
.appendChild(Tmp
.ToXml(Include
, 'PackageHeader'))
1394 DomPackage
.appendChild(PackageIncludeHeaderNode
)
1397 GuidProtocolPpiNode
= CreateXmlElement('GuidDeclarations', '', [], [])
1398 for GuidProtocolPpi
in Package
.GuidDeclarations
:
1399 Tmp
= GuidProtocolPpiXml()
1400 GuidProtocolPpiNode
.appendChild(Tmp
.ToXml(GuidProtocolPpi
, 'Entry'))
1401 DomPackage
.appendChild(GuidProtocolPpiNode
)
1404 GuidProtocolPpiNode
= CreateXmlElement('ProtocolDeclarations', '', [], [])
1405 for GuidProtocolPpi
in Package
.ProtocolDeclarations
:
1406 Tmp
= GuidProtocolPpiXml()
1407 GuidProtocolPpiNode
.appendChild(Tmp
.ToXml(GuidProtocolPpi
, 'Entry'))
1408 DomPackage
.appendChild(GuidProtocolPpiNode
)
1411 GuidProtocolPpiNode
= CreateXmlElement('PpiDeclarations', '', [], [])
1412 for GuidProtocolPpi
in Package
.PpiDeclarations
:
1413 Tmp
= GuidProtocolPpiXml()
1414 GuidProtocolPpiNode
.appendChild(Tmp
.ToXml(GuidProtocolPpi
, 'Entry'))
1415 DomPackage
.appendChild(GuidProtocolPpiNode
)
1418 PcdEntryNode
= CreateXmlElement('PcdDeclarations', '', [], [])
1419 for PcdEntry
in Package
.PcdDeclarations
:
1421 PcdEntryNode
.appendChild(Tmp
.ToXml(PcdEntry
, 'PcdEntry'))
1422 DomPackage
.appendChild(PcdEntryNode
)
1425 PcdCheckNode
= CreateXmlElement('PcdRelationshipChecks', '', [], [])
1426 for PcdCheck
in Package
.PcdChecks
:
1428 PcdCheckNode
.appendChild(Tmp
.ToXml(PcdCheck
, 'PcdCheck'))
1429 DomPackage
.appendChild(PcdCheckNode
)
1432 Tmp
= MiscellaneousFileXml()
1433 DomPackage
.appendChild(Tmp
.ToXml(Package
.MiscFiles
, 'MiscellaneousFiles'))
1436 Tmp
= UserExtensionsXml()
1437 DomPackage
.appendChild(Tmp
.ToXml(Package
.UserExtensions
, 'UserExtensions'))
1440 ModuleNode
= CreateXmlElement('Modules', '', [], [])
1441 for Module
in Package
.Modules
.values():
1442 Tmp
= ModuleSurfaceAreaXml()
1443 ModuleNode
.appendChild(Tmp
.ToXml(Module
))
1444 DomPackage
.appendChild(ModuleNode
)
1449 class ModuleSurfaceAreaXml(object):
1453 def FromXml(self
, Item
, Key
):
1454 # Create a package object
1455 Module
= ModuleClass()
1459 ModuleHeader
= Tmp
.FromXml(XmlNode(Item
, '/ModuleSurfaceArea/Header'), 'Header')
1460 Module
.ModuleHeader
= ModuleHeader
1463 Tmp
= ModulePropertyXml()
1464 (Header
, BootModes
, Events
, HOBs
) = Tmp
.FromXml(XmlNode(Item
, '/ModuleSurfaceArea/ModuleProperties'), 'ModuleProperties', ModuleHeader
)
1465 Module
.ModuleHeader
= Header
1466 Module
.BootModes
= BootModes
1467 Module
.Events
= Events
1471 Tmp
= ClonedFromXml()
1472 ClonedFrom
= Tmp
.FromXml(XmlNode(Item
, '/ModuleSurfaceArea/ClonedFrom'), 'ClonedFrom')
1474 Module
.ModuleHeader
.ClonedFrom
.append(ClonedFrom
)
1477 #LibraryClassNode = CreateXmlElement('LibraryClassDefinitions', '', [], [])
1478 for SubItem
in XmlList(Item
, '/ModuleSurfaceArea/LibraryClassDefinitions/LibraryClass'):
1479 Tmp
= LibraryClassXml()
1480 LibraryClass
= Tmp
.FromXml(SubItem
, 'LibraryClass')
1481 Module
.LibraryClasses
.append(LibraryClass
)
1484 #SourceFileNode = CreateXmlElement('SourceFiles', '', [], [])
1485 for SubItem
in XmlList(Item
, '/ModuleSurfaceArea/SourceFiles/Filename'):
1486 Tmp
= SourceFileXml()
1487 SourceFile
= Tmp
.FromXml(SubItem
, 'Filename')
1488 Module
.Sources
.append(SourceFile
)
1491 #BinaryFileNode = CreateXmlElement('BinaryFiles', '', [], [])
1492 for SubItem
in XmlList(Item
, '/ModuleSurfaceArea/BinaryFiles/BinaryFile'):
1493 Tmp
= BinaryFileXml()
1494 BinaryFile
= Tmp
.FromXml(SubItem
, 'BinaryFile')
1495 Module
.Binaries
.append(BinaryFile
)
1497 # PackageDependencies
1498 #PackageDependencyNode = CreateXmlElement('PackageDependencies', '', [], [])
1499 for SubItem
in XmlList(Item
, '/ModuleSurfaceArea/PackageDependencies/Package'):
1501 PackageDependency
= Tmp
.FromXml(SubItem
, 'Package')
1502 Module
.PackageDependencies
.append(PackageDependency
)
1505 #GuidProtocolPpiNode = CreateXmlElement('Guids', '', [], [])
1506 for SubItem
in XmlList(Item
, '/ModuleSurfaceArea/Guids/GuidCName'):
1507 Tmp
= GuidProtocolPpiXml()
1508 GuidProtocolPpi
= Tmp
.FromXml(SubItem
, 'GuidCName')
1509 Module
.Guids
.append(GuidProtocolPpi
)
1512 #GuidProtocolPpiNode = CreateXmlElement('Protocols', '', [], [])
1513 for SubItem
in XmlList(Item
, '/ModuleSurfaceArea/Protocols/Protocol'):
1514 Tmp
= GuidProtocolPpiXml()
1515 GuidProtocolPpi
= Tmp
.FromXml(SubItem
, 'Protocol')
1516 Module
.Protocols
.append(GuidProtocolPpi
)
1519 #GuidProtocolPpiNode = CreateXmlElement('PPIs', '', [], [])
1520 for SubItem
in XmlList(Item
, '/ModuleSurfaceArea/PPIs/Ppi'):
1521 Tmp
= GuidProtocolPpiXml()
1522 GuidProtocolPpi
= Tmp
.FromXml(SubItem
, 'Ppi')
1523 Module
.Ppis
.append(GuidProtocolPpi
)
1526 #ExternNode = CreateXmlElement('Externs', '', [], [])
1527 for SubItem
in XmlList(Item
, '/ModuleSurfaceArea/Externs/Extern'):
1529 Extern
= Tmp
.FromXml(SubItem
, 'Extern')
1530 Module
.Externs
.append(Extern
)
1533 #PcdEntryNode = CreateXmlElement('PcdCoded', '', [], [])
1534 for SubItem
in XmlList(Item
, '/ModuleSurfaceArea/PcdCoded/PcdEntry'):
1536 PcdEntry
= Tmp
.FromXml(SubItem
, 'PcdEntry')
1537 Module
.PcdCodes
.append(PcdEntry
)
1540 #DepexNode = CreateXmlElement('PeiDepex', '', [], [])
1542 Module
.PeiDepex
= Tmp
.FromXml(XmlNode(Item
, '/ModuleSurfaceArea/PeiDepex'), 'PeiDepex')
1545 #DepexNode = CreateXmlElement('DxeDepex', '', [], [])
1547 Module
.DxeDepex
= Tmp
.FromXml(XmlNode(Item
, '/ModuleSurfaceArea/DxeDepex'), 'DxeDepex')
1550 #DepexNode = CreateXmlElement('SmmDepex', '', [], [])
1552 Module
.SmmDepex
= Tmp
.FromXml(XmlNode(Item
, '/ModuleSurfaceArea/DxeDepex'), 'SmmDepex')
1555 Tmp
= MiscellaneousFileXml()
1556 Module
.MiscFiles
= Tmp
.FromXml(XmlNode(Item
, '/ModuleSurfaceArea/MiscellaneousFiles'), 'MiscellaneousFiles')
1559 Tmp
= UserExtensionsXml()
1560 Module
.UserExtensions
= Tmp
.FromXml(XmlNode(Item
, '/ModuleSurfaceArea/UserExtensions'), 'UserExtensions')
1562 # return the module object
1563 self
.Module
= Module
1566 def ToXml(self
, Module
):
1567 # Create root node of module surface area
1568 DomModule
= minidom
.Document().createElement('ModuleSurfaceArea')
1572 DomModule
.appendChild(Tmp
.ToXml(Module
.ModuleHeader
, 'Header'))
1575 Tmp
= ModulePropertyXml()
1576 DomModule
.appendChild(Tmp
.ToXml(Module
.ModuleHeader
, Module
.BootModes
, Module
.Events
, Module
.Hobs
, 'ModuleProperties'))
1579 Tmp
= ClonedFromXml()
1580 if Module
.ModuleHeader
.ClonedFrom
!= []:
1581 DomModule
.appendChild(Tmp
.ToXml(Module
.ModuleHeader
.ClonedFrom
[0], 'ClonedFrom'))
1584 LibraryClassNode
= CreateXmlElement('LibraryClassDefinitions', '', [], [])
1585 for LibraryClass
in Module
.LibraryClasses
:
1586 Tmp
= LibraryClassXml()
1587 LibraryClassNode
.appendChild(Tmp
.ToXml(LibraryClass
, 'LibraryClass'))
1588 DomModule
.appendChild(LibraryClassNode
)
1591 SourceFileNode
= CreateXmlElement('SourceFiles', '', [], [])
1592 for SourceFile
in Module
.Sources
:
1593 Tmp
= SourceFileXml()
1594 SourceFileNode
.appendChild(Tmp
.ToXml(SourceFile
, 'Filename'))
1595 DomModule
.appendChild(SourceFileNode
)
1598 BinaryFileNode
= CreateXmlElement('BinaryFiles', '', [], [])
1599 for BinaryFile
in Module
.Binaries
:
1600 Tmp
= BinaryFileXml()
1601 BinaryFileNode
.appendChild(Tmp
.ToXml(BinaryFile
, 'BinaryFile'))
1602 DomModule
.appendChild(BinaryFileNode
)
1604 # PackageDependencies
1605 PackageDependencyNode
= CreateXmlElement('PackageDependencies', '', [], [])
1606 for PackageDependency
in Module
.PackageDependencies
:
1608 PackageDependencyNode
.appendChild(Tmp
.ToXml(PackageDependency
, 'Package'))
1609 DomModule
.appendChild(PackageDependencyNode
)
1612 GuidProtocolPpiNode
= CreateXmlElement('Guids', '', [], [])
1613 for GuidProtocolPpi
in Module
.Guids
:
1614 Tmp
= GuidProtocolPpiXml()
1615 GuidProtocolPpiNode
.appendChild(Tmp
.ToXml(GuidProtocolPpi
, 'GuidCName'))
1616 DomModule
.appendChild(GuidProtocolPpiNode
)
1619 GuidProtocolPpiNode
= CreateXmlElement('Protocols', '', [], [])
1620 for GuidProtocolPpi
in Module
.Protocols
:
1621 Tmp
= GuidProtocolPpiXml()
1622 GuidProtocolPpiNode
.appendChild(Tmp
.ToXml(GuidProtocolPpi
, 'Protocol'))
1623 DomModule
.appendChild(GuidProtocolPpiNode
)
1626 GuidProtocolPpiNode
= CreateXmlElement('PPIs', '', [], [])
1627 for GuidProtocolPpi
in Module
.Ppis
:
1628 Tmp
= GuidProtocolPpiXml()
1629 GuidProtocolPpiNode
.appendChild(Tmp
.ToXml(GuidProtocolPpi
, 'Ppi'))
1630 DomModule
.appendChild(GuidProtocolPpiNode
)
1633 ExternNode
= CreateXmlElement('Externs', '', [], [])
1634 for Extern
in Module
.Externs
:
1636 ExternNode
.appendChild(Tmp
.ToXml(Extern
, 'Extern'))
1637 DomModule
.appendChild(ExternNode
)
1640 PcdEntryNode
= CreateXmlElement('PcdCoded', '', [], [])
1641 for PcdEntry
in Module
.PcdCodes
:
1643 PcdEntryNode
.appendChild(Tmp
.ToXml(PcdEntry
, 'PcdEntry'))
1644 DomModule
.appendChild(PcdEntryNode
)
1648 DepexNode
= CreateXmlElement('PeiDepex', '', [], [])
1650 DomModule
.appendChild(Tmp
.ToXml(Module
.PeiDepex
, 'PeiDepex'))
1654 DepexNode
= CreateXmlElement('DxeDepex', '', [], [])
1656 DomModule
.appendChild(Tmp
.ToXml(Module
.DxeDepex
, 'DxeDepex'))
1660 DepexNode
= CreateXmlElement('SmmDepex', '', [], [])
1662 DomModule
.appendChild(Tmp
.ToXml(Module
.SmmDepex
, 'SmmDepex'))
1665 Tmp
= MiscellaneousFileXml()
1666 DomModule
.appendChild(Tmp
.ToXml(Module
.MiscFiles
, 'MiscellaneousFiles'))
1669 Tmp
= UserExtensionsXml()
1670 DomModule
.appendChild(Tmp
.ToXml(Module
.UserExtensions
, 'UserExtensions'))
1674 # DistributionPackageXml
1675 class DistributionPackageXml(object):
1677 self
.Dp
= DistributionPackageClass()
1679 def FromXml(self
, Filename
= None):
1680 if Filename
!= None:
1681 self
.Dp
= DistributionPackageClass()
1684 self
.Pkg
= XmlParseFile(Filename
)
1686 # Parse Header information
1687 Tmp
= DistributionPackageHeaderXml()
1688 DistributionPackageHeader
= Tmp
.FromXml(XmlNode(self
.Pkg
, '/DistributionPackage/DistributionHeader'), 'DistributionHeader')
1689 self
.Dp
.Header
= DistributionPackageHeader
1691 # Parse each PackageSurfaceArea
1692 for Item
in XmlList(self
.Pkg
, '/DistributionPackage/PackageSurfaceArea'):
1693 Psa
= PackageSurfaceAreaXml()
1694 Package
= Psa
.FromXml(Item
, 'PackageSurfaceArea')
1695 self
.Dp
.PackageSurfaceArea
[(Package
.PackageHeader
.Guid
, Package
.PackageHeader
.Version
, Package
.PackageHeader
.CombinePath
)] = Package
1697 # Parse each ModuleSurfaceArea
1698 for Item
in XmlList(self
.Pkg
, '/DistributionPackage/ModuleSurfaceArea'):
1699 Msa
= ModuleSurfaceAreaXml()
1700 Module
= Msa
.FromXml(Item
, 'ModuleSurfaceArea')
1701 self
.Dp
.ModuleSurfaceArea
[(Module
.ModuleHeader
.Guid
, Module
.ModuleHeader
.Version
, Module
.ModuleHeader
.CombinePath
)] = Module
1704 Tmp
= MiscellaneousFileXml()
1705 self
.Dp
.Tools
= Tmp
.FromXml2(XmlNode(self
.Pkg
, '/DistributionPackage/Tools'), 'Tools')
1708 Tmp
= MiscellaneousFileXml()
1709 self
.Dp
.MiscellaneousFiles
= Tmp
.FromXml2(XmlNode(self
.Pkg
, '/DistributionPackage/MiscellaneousFiles'), 'MiscellaneousFiles')
1713 def ToXml(self
, Dp
):
1715 # Parse DistributionPackageHeader
1716 Attrs
= [['xmlns', 'http://www.uefi.org/2008/2.1'],
1717 ['xmlns:xsi', 'http:/www.w3.org/2001/XMLSchema-instance'],
1719 Root
= CreateXmlElement('DistributionPackage', '', [], Attrs
)
1721 Tmp
= DistributionPackageHeaderXml()
1722 Root
.appendChild(Tmp
.ToXml(Dp
.Header
, 'DistributionHeader'))
1724 # Parse each PackageSurfaceArea
1725 for Package
in Dp
.PackageSurfaceArea
.values():
1726 Psa
= PackageSurfaceAreaXml()
1727 DomPackage
= Psa
.ToXml(Package
)
1728 Root
.appendChild(DomPackage
)
1730 # Parse each ModuleSurfaceArea
1731 for Module
in Dp
.ModuleSurfaceArea
.values():
1732 Msa
= ModuleSurfaceAreaXml()
1733 DomModule
= Msa
.ToXml(Module
)
1734 Root
.appendChild(DomModule
)
1737 Tmp
= MiscellaneousFileXml()
1738 #Tools = Tmp.FromXml2(XmlNode(self.Pkg, '/DistributionPackage/Tools'), 'Tools')
1739 Root
.appendChild(Tmp
.ToXml2(Dp
.Tools
, 'Tools'))
1742 Tmp
= MiscellaneousFileXml()
1743 #Tools = Tmp.FromXml2(XmlNode(self.Pkg, '/DistributionPackage/MiscellaneousFiles'), 'MiscellaneousFiles')
1744 Root
.appendChild(Tmp
.ToXml2(Dp
.MiscellaneousFiles
, 'MiscellaneousFiles'))
1746 return Root
.toprettyxml(indent
= ' ')
1750 if __name__
== '__main__':
1751 M
= DistributionPackageXml()
1752 M
.FromXml('C:\Test.xml')