1## @file
2# This file is used to parse a Module file of .PKG file
3#
4# Copyright (c) 2011 - 2018, Intel Corporation. All rights reserved.<BR>
5#
6# SPDX-License-Identifier: BSD-2-Clause-Patent
7#
8
9'''
10ModuleSurfaceAreaXml
11'''
12from xml.dom import minidom
13
14from Library.StringUtils import ConvertNEToNOTEQ
15from Library.StringUtils import ConvertNOTEQToNE
16from Library.StringUtils import GetStringOfList
17from Library.StringUtils import IsMatchArch
18from Library.Xml.XmlRoutines import XmlElement
19from Library.Xml.XmlRoutines import XmlAttribute
20from Library.Xml.XmlRoutines import XmlNode
21from Library.Xml.XmlRoutines import XmlList
22from Library.Xml.XmlRoutines import CreateXmlElement
23from Object.POM.CommonObject import GuidVersionObject
24from Object.POM.ModuleObject import BootModeObject
25from Object.POM.ModuleObject import DepexObject
26from Object.POM.ModuleObject import ModuleObject
27from Object.POM.ModuleObject import EventObject
28from Object.POM.ModuleObject import HobObject
29from Object.POM.ModuleObject import SourceFileObject
30from Object.POM.ModuleObject import PackageDependencyObject
31from Object.POM.ModuleObject import ExternObject
32from Object.POM.ModuleObject import BinaryFileObject
33from Object.POM.ModuleObject import AsBuiltObject
34from Object.POM.ModuleObject import BinaryBuildFlagObject
35from Xml.CommonXml import ClonedFromXml
36from Xml.CommonXml import HeaderXml
37from Xml.CommonXml import HelpTextXml
38from Xml.CommonXml import CommonDefinesXml
39from Xml.CommonXml import LibraryClassXml
40from Xml.CommonXml import UserExtensionsXml
41from Xml.CommonXml import MiscellaneousFileXml
42from Xml.CommonXml import FilenameXml
43from Xml.GuidProtocolPpiXml import GuidXml
44from Xml.GuidProtocolPpiXml import ProtocolXml
45from Xml.GuidProtocolPpiXml import PpiXml
46from Xml.PcdXml import PcdEntryXml
47from Xml.XmlParserMisc import GetHelpTextList
48from Library import GlobalData
49from Library.Misc import GetSplitValueList
50
51##   BinaryFileXml
52#
53#    represent the following XML item
54#
55#    <BinaryFile>
56#    <Filename
57#    FileType=" FileType " {1}
58#    SupArchList=" ArchListType " {0,1}
59#    FeatureFlag=" FeatureFlagExpression " {0,1} >
60#    xs:anyURI
61#    </Filename> {1,}
62#    <AsBuilt> ... </AsBuilt> {0,}
63#    </BinaryFile> {1,}
64#
65class BinaryFileXml(object):
66    def __init__(self):
67        self.FileNames = []
68        self.AsBuiltList = []
69        self.PatchPcdValues = ''
70        self.PcdExValues = ''
71        self.LibraryInstances = ''
72        self.BuildFlags = ''
73
74    def FromXml(self, Item, Key):
75        if self.FileNames:
76            pass
77        BinaryFile = BinaryFileObject()
78        FilenameList = []
79        SupArchList = ['COMMON']
80        for SubItem in XmlList(Item, '%s/Filename' % Key):
81            Axml = FilenameXml()
82            Bxml = Axml.FromXml(SubItem, 'Filename')
83            FilenameList.append(Bxml)
84        BinaryFile.SetFileNameList(FilenameList)
85        for FileName in FilenameList:
86            if FileName.GetSupArchList():
87                SupArchList = FileName.GetSupArchList()
88        BinaryFile.SetSupArchList(SupArchList)
89        if GlobalData.gIS_BINARY_INF:
90            AsBuiltList = []
91            for AsBuiltItem in XmlList(Item, '%s/AsBuilt' % Key):
92                AsBuilt = AsBuiltObject()
93
94                PatchPcdValueList = []
95                for SubItem in XmlList(AsBuiltItem, 'AsBuilt/PatchPcdValue'):
96                    Axml = PcdEntryXml()
97                    Bxml = Axml.FromXml(SubItem, 'PatchPcdValue')
98                    PatchPcdValueList.append(Bxml)
99                AsBuilt.SetPatchPcdList(PatchPcdValueList)
100                PcdExValueList = []
101                for SubItem in XmlList(AsBuiltItem, 'AsBuilt/PcdExValue'):
102                    Axml = PcdEntryXml()
103                    Bxml = Axml.FromXml(SubItem, 'PcdExValue')
104                    PcdExValueList.append(Bxml)
105                AsBuilt.SetPcdExList(PcdExValueList)
106                LibraryList = []
107                for SubItem in XmlList(Item, '%s/AsBuilt/LibraryInstances/GUID' % Key):
108                    GuidVerObj = GuidVersionObject()
109                    GUID = XmlElement(SubItem, 'GUID')
110                    Version = XmlAttribute(XmlNode(SubItem, 'GUID'), 'Version')
111                    GuidVerObj.SetGuid(GUID)
112                    GuidVerObj.SetVersion(Version)
113                    LibraryList.append(GuidVerObj)
114                if XmlList(Item, '%s/AsBuilt/LibraryInstances' % Key) and not LibraryList:
115                    LibraryList = [None]
116                AsBuilt.SetLibraryInstancesList(LibraryList)
117                BuildFlagList = []
118                for SubItem in XmlList(Item, '%s/AsBuilt/BuildFlags' % Key):
119                    BuildFlag = BuildFlagXml()
120                    BuildFlagList.append(BuildFlag.FromXml2(SubItem, 'BuildFlags'))
121                AsBuilt.SetBuildFlagsList(BuildFlagList)
122                AsBuiltList.append(AsBuilt)
123            BinaryFile.SetAsBuiltList(AsBuiltList)
124        return BinaryFile
125
126    def ToXml(self, BinaryFile, Key):
127        if self.FileNames:
128            pass
129        NodeList = []
130        FilenameList = BinaryFile.GetFileNameList()
131        SupportArch = None
132        for Filename in FilenameList:
133            Tmp = FilenameXml()
134            NodeList.append(Tmp.ToXml(Filename, 'Filename'))
135            SupportArch = Filename.SupArchList
136
137        AsBuildList = BinaryFile.GetAsBuiltList()
138        PatchPcdValueList = AsBuildList.GetPatchPcdList()
139        PcdExList = AsBuildList.GetPcdExList()
140        LibGuidVerList = AsBuildList.GetLibraryInstancesList()
141        BuildFlagList = AsBuildList.GetBuildFlagsList()
142
143        AsBuiltNodeList = []
144
145        for Pcd in PatchPcdValueList:
146            if IsMatchArch(Pcd.SupArchList, SupportArch):
147                Tmp = PcdEntryXml()
148                AsBuiltNodeList.append(Tmp.ToXml4(Pcd, 'PatchPcdValue'))
149
150        for Pcd in PcdExList:
151            if IsMatchArch(Pcd.SupArchList, SupportArch):
152                Tmp = PcdEntryXml()
153                AsBuiltNodeList.append(Tmp.ToXml4(Pcd, 'PcdExValue'))
154
155        GuiVerElemList = []
156        for LibGuidVer in LibGuidVerList:
157            if LibGuidVer.GetLibGuid() and IsMatchArch(LibGuidVer.GetSupArchList(), SupportArch):
158                GuiVerElem = \
159                CreateXmlElement('GUID', LibGuidVer.GetLibGuid(), [], [['Version', LibGuidVer.GetLibVersion()]])
160                GuiVerElemList.append(GuiVerElem)
161        if len(GuiVerElemList) > 0:
162            LibGuidVerElem = CreateXmlElement('LibraryInstances', '', GuiVerElemList, [])
163            AsBuiltNodeList.append(LibGuidVerElem)
164
165        for BuildFlag in BuildFlagList:
166            if IsMatchArch(BuildFlag.GetSupArchList(), SupportArch):
167                for Item in BuildFlag.GetAsBuildList():
168                    Tmp = BuildFlagXml()
169                    Elem = CreateXmlElement('BuildFlags', ''.join(Item), [], [])
170                    AsBuiltNodeList.append(Elem)
171
172        if len(AsBuiltNodeList) > 0:
173            Element = CreateXmlElement('AsBuilt', '', AsBuiltNodeList, [])
174            NodeList.append(Element)
175
176        Root = CreateXmlElement('%s' % Key, '', NodeList, [])
177
178        return Root
179
180    def __str__(self):
181        Str = "BinaryFiles:"
182        for Item in self.FileNames:
183            Str = Str + '\n\t' + str(Item)
184        for Item in self.PatchPcdValues:
185            Str = Str + '\n\t' + str(Item)
186        for Item in self.PcdExValues:
187            Str = Str + '\n\t' + str(Item)
188        for Item in self.LibraryInstances:
189            Str = Str + '\n\t' + str(Item)
190        for Item in self.BuildFlags:
191            Str = Str + '\n\t' + str(Item)
192        return Str
193
194##
195# PackageXml
196#
197class PackageXml(object):
198    def __init__(self):
199        self.Description = ''
200        self.Guid = ''
201        self.Version = ''
202        self.CommonDefines = CommonDefinesXml()
203
204    def FromXml(self, Item, Key):
205        self.Description = XmlElement(Item, '%s/Description' % Key)
206        self.Guid = XmlElement(Item, '%s/GUID' % Key)
207        self.Version = XmlAttribute(XmlNode(Item, '%s/GUID' % Key), 'Version')
208        self.CommonDefines.FromXml(XmlNode(Item, '%s' % Key), Key)
209
210        PackageDependency = PackageDependencyObject()
211        PackageDependency.SetPackage(self.Description)
212        PackageDependency.SetGuid(self.Guid)
213        PackageDependency.SetVersion(self.Version)
214        PackageDependency.SetFeatureFlag(ConvertNOTEQToNE(self.CommonDefines.FeatureFlag))
215        PackageDependency.SetSupArchList(self.CommonDefines.SupArchList)
216
217        return PackageDependency
218
219    def ToXml(self, PackageDependency, Key):
220        if self.Guid:
221            pass
222        AttributeList = [['SupArchList', GetStringOfList(PackageDependency.GetSupArchList())],
223                         ['FeatureFlag', ConvertNEToNOTEQ(PackageDependency.GetFeatureFlag())], ]
224        Element1 = CreateXmlElement('GUID', PackageDependency.GetGuid(), [],
225                                    [['Version', PackageDependency.GetVersion()]])
226        NodeList = [['Description', PackageDependency.GetPackage()], Element1, ]
227        Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
228
229        return Root
230
231    def __str__(self):
232        Str = "Description = %s Guid = %s Version = %s %s" \
233              % (self.Description, self.Guid, self.Version, self.CommonDefines)
234        return Str
235##
236# ExternXml
237#
238class ExternXml(object):
239    def __init__(self):
240        self.CommonDefines = CommonDefinesXml()
241        self.EntryPoint = ''
242        self.UnloadImage = ''
243        self.Constructor = ''
244        self.Destructor = ''
245        self.SupModList = ''
246        self.SupArchList = ''
247        self.HelpText = []
248
249    def FromXml(self, Item, Key):
250        self.CommonDefines.FromXml(Item, Key)
251        self.EntryPoint = XmlElement(Item, '%s/EntryPoint' % Key)
252        self.UnloadImage = XmlElement(Item, '%s/UnloadImage' % Key)
253        self.Constructor = XmlElement(Item, '%s/Constructor' % Key)
254        self.Destructor = XmlElement(Item, '%s/Destructor' % Key)
255
256        Extern = ExternObject()
257        Extern.SetEntryPoint(self.EntryPoint)
258        Extern.SetUnloadImage(self.UnloadImage)
259        Extern.SetConstructor(self.Constructor)
260        Extern.SetDestructor(self.Destructor)
261        if self.CommonDefines.SupModList:
262            Extern.SetSupModList(self.CommonDefines.SupModList)
263        if self.CommonDefines.SupArchList:
264            Extern.SetSupArchList(self.CommonDefines.SupArchList)
265        return Extern
266
267    def ToXml(self, Extern, Key):
268        if self.HelpText:
269            pass
270
271        NodeList = []
272        if Extern.GetEntryPoint():
273            NodeList.append(['EntryPoint', Extern.GetEntryPoint()])
274        if Extern.GetUnloadImage():
275            NodeList.append(['UnloadImage', Extern.GetUnloadImage()])
276        if Extern.GetConstructor():
277            NodeList.append(['Constructor', Extern.GetConstructor()])
278        if Extern.GetDestructor():
279            NodeList.append(['Destructor', Extern.GetDestructor()])
280        Root = CreateXmlElement('%s' % Key, '', NodeList, [])
281
282        return Root
283
284    def __str__(self):
285        Str = "EntryPoint = %s UnloadImage = %s Constructor = %s Destructor = %s %s" \
286              % (self.EntryPoint, self.UnloadImage, self.Constructor, self.Destructor, self.CommonDefines)
287        for Item in self.HelpText:
288            Str = Str + '\n\t' + str(Item)
289        return Str
290##
291# DepexXml
292#
293class DepexXml(object):
294    def __init__(self):
295        self.CommonDefines = CommonDefinesXml()
296        self.Expression = None
297        self.HelpText = []
298
299    def FromXml(self, Item, Key):
300        if not Item:
301            return None
302        self.CommonDefines.FromXml(Item, Key)
303        self.Expression = XmlElement(Item, '%s/Expression' % Key)
304        for HelpTextItem in XmlList(Item, '%s/HelpText' % Key):
305            HelpTextObj = HelpTextXml()
306            HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)
307            self.HelpText.append(HelpTextObj)
308
309        Depex = DepexObject()
310        Depex.SetDepex(self.Expression)
311        Depex.SetModuleType(self.CommonDefines.SupModList)
312        Depex.SetSupArchList(self.CommonDefines.SupArchList)
313        Depex.SetFeatureFlag(self.CommonDefines.FeatureFlag)
314        Depex.SetHelpTextList(GetHelpTextList(self.HelpText))
315
316        return Depex
317
318    def ToXml(self, Depex, Key):
319        if self.HelpText:
320            pass
321        AttributeList = [['SupArchList', GetStringOfList(Depex.GetSupArchList())],
322                         ['SupModList', Depex.GetModuleType()]]
323        NodeList = [['Expression', Depex.GetDepex()]]
324        if Depex.GetHelpText():
325            Tmp = HelpTextXml()
326            NodeList.append(Tmp.ToXml(Depex.GetHelpText(), 'HelpText'))
327
328        Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
329        return Root
330
331    def __str__(self):
332        Str = "Expression = %s" % (self.Expression)
333        for Item in self.HelpText:
334            Str = Str + '\n\t' + str(Item)
335        return Str
336
337##
338# BootModeXml
339#
340class BootModeXml(object):
341    def __init__(self):
342        self.SupportedBootModes = ''
343        self.CommonDefines = CommonDefinesXml()
344        self.HelpText = []
345
346    def FromXml(self, Item, Key):
347        self.SupportedBootModes = \
348        XmlElement(Item, '%s/SupportedBootModes' % Key)
349        self.CommonDefines.FromXml(Item, Key)
350        for HelpTextItem in XmlList(Item, '%s/HelpText' % Key):
351            HelpTextObj = HelpTextXml()
352            HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)
353            self.HelpText.append(HelpTextObj)
354
355        BootMode = BootModeObject()
356        BootMode.SetSupportedBootModes(self.SupportedBootModes)
357        BootMode.SetUsage(self.CommonDefines.Usage)
358        BootMode.SetHelpTextList(GetHelpTextList(self.HelpText))
359
360        return BootMode
361
362    def ToXml(self, BootMode, Key):
363        if self.HelpText:
364            pass
365        AttributeList = [['Usage', BootMode.GetUsage()], ]
366        NodeList = [['SupportedBootModes', BootMode.GetSupportedBootModes()]]
367        for Item in BootMode.GetHelpTextList():
368            Tmp = HelpTextXml()
369            NodeList.append(Tmp.ToXml(Item, 'HelpText'))
370        Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
371
372        return Root
373
374    def __str__(self):
375        Str = "SupportedBootModes = %s %s" % (self.SupportedBootModes, self.CommonDefines)
376        for Item in self.HelpText:
377            Str = Str + '\n\t' + str(Item)
378        return Str
379##
380# EventXml
381#
382class EventXml(object):
383    def __init__(self):
384        self.EventType = ''
385        self.Name = ''
386        self.CommonDefines = CommonDefinesXml()
387        self.HelpText = []
388
389    def FromXml(self, Item, Key):
390        self.EventType = XmlAttribute(XmlNode(Item, '%s' % Key), 'EventType')
391        self.Name = XmlElement(Item, '%s' % Key)
392        self.CommonDefines.FromXml(Item, Key)
393        for HelpTextItem in XmlList(Item, '%s/HelpText' % Key):
394            HelpTextObj = HelpTextXml()
395            HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)
396            self.HelpText.append(HelpTextObj)
397
398        Event = EventObject()
399        Event.SetEventType(self.EventType)
400        Event.SetUsage(self.CommonDefines.Usage)
401        Event.SetHelpTextList(GetHelpTextList(self.HelpText))
402
403        return Event
404
405    def ToXml(self, Event, Key):
406        if self.HelpText:
407            pass
408        AttributeList = [['EventType', Event.GetEventType()],
409                         ['Usage', Event.GetUsage()],
410                        ]
411        NodeList = []
412        for Item in Event.GetHelpTextList():
413            Tmp = HelpTextXml()
414            NodeList.append(Tmp.ToXml(Item, 'HelpText'))
415        Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
416
417        return Root
418
419    def __str__(self):
420        Str = "EventType = %s %s" % (self.EventType, self.CommonDefines)
421        for Item in self.HelpText:
422            Str = Str + '\n\t' + str(Item)
423        return Str
424##
425# HobXml
426#
427class HobXml(object):
428    def __init__(self):
429        self.HobType = ''
430        self.Name = ''
431        self.CommonDefines = CommonDefinesXml()
432        self.HelpText = []
433
434    def FromXml(self, Item, Key):
435        self.HobType = XmlAttribute(XmlNode(Item, '%s' % Key), 'HobType')
436        self.Name = XmlElement(Item, '%s' % Key)
437        self.CommonDefines.FromXml(Item, Key)
438        for HelpTextItem in XmlList(Item, '%s/HelpText' % Key):
439            HelpTextObj = HelpTextXml()
440            HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)
441            self.HelpText.append(HelpTextObj)
442
443        Hob = HobObject()
444        Hob.SetHobType(self.HobType)
445        Hob.SetSupArchList(self.CommonDefines.SupArchList)
446        Hob.SetUsage(self.CommonDefines.Usage)
447        Hob.SetHelpTextList(GetHelpTextList(self.HelpText))
448
449        return Hob
450
451    def ToXml(self, Hob, Key):
452        if self.Name:
453            pass
454        AttributeList = [['HobType', Hob.GetHobType()],
455                         ['Usage', Hob.GetUsage()],
456                         ['SupArchList', GetStringOfList(Hob.GetSupArchList())], ]
457        NodeList = []
458        for Item in Hob.GetHelpTextList():
459            Tmp = HelpTextXml()
460            NodeList.append(Tmp.ToXml(Item, 'HelpText'))
461        Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
462
463        return Root
464
465    def __str__(self):
466        Str = "HobType = %s %s" % (self.HobType, self.CommonDefines)
467        for Item in self.HelpText:
468            Str = Str + '\n\t' + str(Item)
469        return Str
470
471##
472# SourceFileXml
473#
474class SourceFileXml(object):
475    def __init__(self):
476        self.SourceFile = ''
477        self.ToolChainFamily = ''
478        self.FileType = ''
479        self.CommonDefines = CommonDefinesXml()
480
481    def FromXml(self, Item, Key):
482        self.ToolChainFamily = XmlAttribute(Item, 'Family')
483        self.SourceFile = XmlElement(Item, 'Filename')
484        self.CommonDefines.FromXml(Item, Key)
485
486        self.CommonDefines.FeatureFlag = ConvertNOTEQToNE(self.CommonDefines.FeatureFlag)
487
488        SourceFile = SourceFileObject()
489        SourceFile.SetSourceFile(self.SourceFile)
490        SourceFile.SetFamily(self.ToolChainFamily)
491        SourceFile.SetSupArchList(self.CommonDefines.SupArchList)
492        SourceFile.SetFeatureFlag(self.CommonDefines.FeatureFlag)
493
494        return SourceFile
495
496    def ToXml(self, SourceFile, Key):
497        if self.SourceFile:
498            pass
499        FeatureFlag = ConvertNEToNOTEQ(SourceFile.GetFeatureFlag())
500        AttributeList = [['SupArchList', GetStringOfList(SourceFile.GetSupArchList())],
501                         ['Family', SourceFile.GetFamily()],
502                         ['FeatureFlag', FeatureFlag], ]
503        Root = CreateXmlElement('%s' % Key, SourceFile.GetSourceFile(), [], AttributeList)
504        return Root
505
506##
507# ModulePropertyXml
508#
509class ModulePropertyXml(object):
510    def __init__(self):
511        self.CommonDefines = CommonDefinesXml()
512        self.ModuleType = ''
513        self.Path = ''
514        self.PcdIsDriver = ''
515        self.UefiSpecificationVersion = ''
516        self.PiSpecificationVersion = ''
517        self.SpecificationList = []
518        self.SpecificationVersion = ''
519        self.BootModes = []
520        self.Events = []
521        self.HOBs = []
522
523    def FromXml(self, Item, Key, Header=None):
524        self.CommonDefines.FromXml(Item, Key)
525        self.ModuleType = XmlElement(Item, '%s/ModuleType' % Key)
526        self.Path = XmlElement(Item, '%s/Path' % Key)
527        self.PcdIsDriver = XmlElement(Item, '%s/PcdIsDriver' % Key)
528        self.UefiSpecificationVersion = XmlElement(Item, '%s/UefiSpecificationVersion' % Key)
529        self.PiSpecificationVersion = XmlElement(Item, '%s/PiSpecificationVersion' % Key)
530        for SubItem in XmlList(Item, '%s/Specification' % Key):
531            Specification = XmlElement(SubItem, '/Specification')
532            Version = XmlAttribute(XmlNode(SubItem, '/Specification'), 'Version')
533            self.SpecificationList.append((Specification, Version))
534        for SubItem in XmlList(Item, '%s/BootMode' % Key):
535            Axml = BootModeXml()
536            BootMode = Axml.FromXml(SubItem, 'BootMode')
537            self.BootModes.append(BootMode)
538        for SubItem in XmlList(Item, '%s/Event' % Key):
539            Axml = EventXml()
540            Event = Axml.FromXml(SubItem, 'Event')
541            self.Events.append(Event)
542        for SubItem in XmlList(Item, '%s/HOB' % Key):
543            Axml = HobXml()
544            Hob = Axml.FromXml(SubItem, 'HOB')
545            self.HOBs.append(Hob)
546
547        if Header is None:
548            Header = ModuleObject()
549
550        Header.SetModuleType(self.ModuleType)
551        Header.SetSupArchList(self.CommonDefines.SupArchList)
552        Header.SetModulePath(self.Path)
553
554        Header.SetPcdIsDriver(self.PcdIsDriver)
555        Header.SetUefiSpecificationVersion(self.UefiSpecificationVersion)
556        Header.SetPiSpecificationVersion(self.PiSpecificationVersion)
557        Header.SetSpecList(self.SpecificationList)
558
559        return Header, self.BootModes, self.Events, self.HOBs
560
561
562    def ToXml(self, Header, BootModes, Events, Hobs, Key):
563        if self.ModuleType:
564            pass
565        AttributeList = [['SupArchList', GetStringOfList(Header.GetSupArchList())], ]
566
567        NodeList = [['ModuleType', Header.GetModuleType()],
568                    ['Path', Header.GetModulePath()],
569                    ['PcdIsDriver', Header.GetPcdIsDriver()],
570                    ['UefiSpecificationVersion', Header.GetUefiSpecificationVersion()],
571                    ['PiSpecificationVersion', Header.GetPiSpecificationVersion()],
572                   ]
573        for Item in Header.GetSpecList():
574            Spec, Version = Item
575            SpecElem = CreateXmlElement('Specification', Spec, [], [['Version', Version]])
576            NodeList.append(SpecElem)
577
578        for Item in BootModes:
579            Tmp = BootModeXml()
580            NodeList.append(Tmp.ToXml(Item, 'BootMode'))
581        for Item in Events:
582            Tmp = EventXml()
583            NodeList.append(Tmp.ToXml(Item, 'Event'))
584        for Item in Hobs:
585            Tmp = HobXml()
586            NodeList.append(Tmp.ToXml(Item, 'HOB'))
587        Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
588
589        return Root
590
591    def __str__(self):
592        Str = "ModuleType = %s Path = %s PcdIsDriver = %s UefiSpecificationVersion = %s PiSpecificationVersion = %s \
593               Specification = %s SpecificationVersion = %s %s" % \
594        (self.ModuleType, self.Path, self.PcdIsDriver, \
595         self.UefiSpecificationVersion, self.PiSpecificationVersion, \
596         self.SpecificationList, self.SpecificationVersion, self.CommonDefines)
597        for Item in self.BootModes:
598            Str = Str + '\n\t' + str(Item)
599        for Item in self.Events:
600            Str = Str + '\n\t' + str(Item)
601        for Item in self.HOBs:
602            Str = Str + '\n\t' + str(Item)
603        return Str
604
605##
606# ModuleXml
607#
608class ModuleSurfaceAreaXml(object):
609    def __init__(self, Package=''):
610        self.Module = None
611        #
612        # indicate the package that this module resides in
613        #
614        self.Package = Package
615
616    def FromXml2(self, Item, Module):
617        if self.Module:
618            pass
619        #
620        # PeiDepex
621        #
622        PeiDepexList = []
623        for SubItem in XmlList(Item, '/ModuleSurfaceArea/PeiDepex'):
624            Tmp = DepexXml()
625            Depex = Tmp.FromXml(XmlNode(SubItem, 'PeiDepex'), 'PeiDepex')
626            PeiDepexList.append(Depex)
627        Module.SetPeiDepex(PeiDepexList)
628
629        #
630        # DxeDepex
631        #
632        DxeDepexList = []
633        for SubItem in XmlList(Item, '/ModuleSurfaceArea/DxeDepex'):
634            Tmp = DepexXml()
635            Depex = Tmp.FromXml(XmlNode(SubItem, 'DxeDepex'), 'DxeDepex')
636            DxeDepexList.append(Depex)
637        Module.SetDxeDepex(DxeDepexList)
638
639        #
640        # SmmDepex
641        #
642        SmmDepexList = []
643        for SubItem in XmlList(Item, '/ModuleSurfaceArea/SmmDepex'):
644            Tmp = DepexXml()
645            Depex = Tmp.FromXml(XmlNode(SubItem, 'SmmDepex'), 'SmmDepex')
646            SmmDepexList.append(Depex)
647        Module.SetSmmDepex(SmmDepexList)
648
649        #
650        # MiscellaneousFile
651        Tmp = MiscellaneousFileXml()
652        MiscFileList = Tmp.FromXml(XmlNode(Item, '/ModuleSurfaceArea/MiscellaneousFiles'), 'MiscellaneousFiles')
653        if MiscFileList:
654            Module.SetMiscFileList([MiscFileList])
655        else:
656            Module.SetMiscFileList([])
657
658        #
659        # UserExtensions
660        #
661        for Item in XmlList(Item, '/ModuleSurfaceArea/UserExtensions'):
662            Tmp = UserExtensionsXml()
663            UserExtension = Tmp.FromXml(Item, 'UserExtensions')
664            Module.SetUserExtensionList(Module.GetUserExtensionList() + [UserExtension])
665
666        return Module
667
668    def FromXml(self, Item, Key, IsStandAlongModule=False):
669        IsBinaryModule = XmlAttribute(Item, 'BinaryModule')
670        #
671        # Header
672        #
673        Tmp = HeaderXml()
674        Module = Tmp.FromXml(XmlNode(Item, '/%s/Header' % Key), 'Header', True, IsStandAlongModule)
675        Module.SetBinaryModule(IsBinaryModule)
676
677        if IsBinaryModule:
678            GlobalData.gIS_BINARY_INF = True
679
680        #
681        # ModuleProperties
682        #
683        Tmp = ModulePropertyXml()
684        (Module, BootModes, Events, HOBs) = \
685        Tmp.FromXml(XmlNode(Item, '/ModuleSurfaceArea/ModuleProperties'), 'ModuleProperties', Module)
686        Module.SetBootModeList(BootModes)
687        Module.SetEventList(Events)
688        Module.SetHobList(HOBs)
689        #
690        # ClonedFrom
691        #
692        Tmp = ClonedFromXml()
693        ClonedFrom = Tmp.FromXml(XmlNode(Item, '/ModuleSurfaceArea/ClonedFrom'), 'ClonedFrom')
694        if ClonedFrom:
695            Module.SetClonedFrom(ClonedFrom)
696
697        #
698        # LibraryClass
699        #
700        for SubItem in XmlList(Item, '/ModuleSurfaceArea/LibraryClassDefinitions/LibraryClass'):
701            Tmp = LibraryClassXml()
702            LibraryClass = Tmp.FromXml(SubItem, 'LibraryClass')
703            Module.SetLibraryClassList(Module.GetLibraryClassList() + [LibraryClass])
704
705        if XmlList(Item, '/ModuleSurfaceArea/LibraryClassDefinitions') and \
706           not XmlList(Item, '/ModuleSurfaceArea/LibraryClassDefinitions/LibraryClass'):
707            Module.SetLibraryClassList([None])
708
709        #
710        # SourceFiles
711        #
712        for SubItem in XmlList(Item, '/ModuleSurfaceArea/SourceFiles/Filename'):
713            Tmp = SourceFileXml()
714            SourceFile = Tmp.FromXml(SubItem, 'Filename')
715            Module.SetSourceFileList(Module.GetSourceFileList() + [SourceFile])
716
717        if XmlList(Item, '/ModuleSurfaceArea/SourceFiles') and \
718           not XmlList(Item, '/ModuleSurfaceArea/SourceFiles/Filename') :
719            Module.SetSourceFileList([None])
720
721        #
722        # BinaryFile
723        #
724        for SubItem in XmlList(Item, '/ModuleSurfaceArea/BinaryFiles/BinaryFile'):
725            Tmp = BinaryFileXml()
726            BinaryFile = Tmp.FromXml(SubItem, 'BinaryFile')
727            Module.SetBinaryFileList(Module.GetBinaryFileList() + [BinaryFile])
728
729        if XmlList(Item, '/ModuleSurfaceArea/BinaryFiles') and \
730           not XmlList(Item, '/ModuleSurfaceArea/BinaryFiles/BinaryFile') :
731            Module.SetBinaryFileList([None])
732        #
733        # PackageDependencies
734        #
735        for SubItem in XmlList(Item, '/ModuleSurfaceArea/PackageDependencies/Package'):
736            Tmp = PackageXml()
737            PackageDependency = Tmp.FromXml(SubItem, 'Package')
738            Module.SetPackageDependencyList(Module.GetPackageDependencyList() + [PackageDependency])
739
740        if XmlList(Item, '/ModuleSurfaceArea/PackageDependencies') and \
741           not XmlList(Item, '/ModuleSurfaceArea/PackageDependencies/Package'):
742            Module.SetPackageDependencyList([None])
743
744        #
745        # Guid
746        #
747        for SubItem in XmlList(Item, '/ModuleSurfaceArea/Guids/GuidCName'):
748            Tmp = GuidXml('Module')
749            GuidProtocolPpi = Tmp.FromXml(SubItem, 'GuidCName')
750            Module.SetGuidList(Module.GetGuidList() + [GuidProtocolPpi])
751
752        if XmlList(Item, '/ModuleSurfaceArea/Guids') and not XmlList(Item, '/ModuleSurfaceArea/Guids/GuidCName'):
753            Module.SetGuidList([None])
754
755        #
756        # Protocol
757        #
758        for SubItem in XmlList(Item, '/ModuleSurfaceArea/Protocols/Protocol'):
759            Tmp = ProtocolXml('Module')
760            GuidProtocolPpi = Tmp.FromXml(SubItem, 'Protocol')
761            Module.SetProtocolList(Module.GetProtocolList() + [GuidProtocolPpi])
762
763        if XmlList(Item, '/ModuleSurfaceArea/Protocols') and not XmlList(Item, '/ModuleSurfaceArea/Protocols/Protocol'):
764            Module.SetProtocolList([None])
765
766        #
767        # Ppi
768        #
769        for SubItem in XmlList(Item, '/ModuleSurfaceArea/PPIs/Ppi'):
770            Tmp = PpiXml('Module')
771            GuidProtocolPpi = Tmp.FromXml(SubItem, 'Ppi')
772            Module.SetPpiList(Module.GetPpiList() + [GuidProtocolPpi])
773
774        if XmlList(Item, '/ModuleSurfaceArea/PPIs') and not XmlList(Item, '/ModuleSurfaceArea/PPIs/Ppi'):
775            Module.SetPpiList([None])
776
777        #
778        # Extern
779        #
780        for SubItem in XmlList(Item, '/ModuleSurfaceArea/Externs/Extern'):
781            Tmp = ExternXml()
782            Extern = Tmp.FromXml(SubItem, 'Extern')
783            Module.SetExternList(Module.GetExternList() + [Extern])
784
785        if XmlList(Item, '/ModuleSurfaceArea/Externs') and not XmlList(Item, '/ModuleSurfaceArea/Externs/Extern'):
786            Module.SetExternList([None])
787
788        if not Module.GetBinaryModule():
789            #
790            # PcdCoded
791            #
792            for SubItem in XmlList(Item, '/ModuleSurfaceArea/PcdCoded/PcdEntry'):
793                Tmp = PcdEntryXml()
794                PcdEntry = Tmp.FromXml3(SubItem, 'PcdEntry')
795                Module.SetPcdList(Module.GetPcdList() + [PcdEntry])
796
797            if XmlList(Item, '/ModuleSurfaceArea/PcdCoded') and \
798                not XmlList(Item, '/ModuleSurfaceArea/PcdCoded/PcdEntry'):
799                Module.SetPcdList([None])
800
801        Module = self.FromXml2(Item, Module)
802        #
803        # return the module object
804        #
805        self.Module = Module
806        return self.Module
807
808    def ToXml(self, Module):
809        if self.Package:
810            pass
811        #
812        # Create root node of module surface area
813        #
814        DomModule = minidom.Document().createElement('ModuleSurfaceArea')
815        if Module.GetBinaryModule():
816            DomModule.setAttribute('BinaryModule', 'true')
817
818        #
819        # Header
820        #
821        Tmp = HeaderXml()
822        DomModule.appendChild(Tmp.ToXml(Module, 'Header'))
823        #
824        # ModuleProperties
825        #
826        Tmp = ModulePropertyXml()
827        DomModule.appendChild(Tmp.ToXml(Module, Module.GetBootModeList(), Module.GetEventList(), Module.GetHobList(), \
828                                        'ModuleProperties'))
829        #
830        # ClonedFrom
831        #
832        Tmp = ClonedFromXml()
833        if Module.GetClonedFrom():
834            DomModule.appendChild(Tmp.ToXml(Module.GetClonedFrom(), 'ClonedFrom'))
835        #
836        # LibraryClass
837        #
838        LibraryClassNode = CreateXmlElement('LibraryClassDefinitions', '', [], [])
839        for LibraryClass in Module.GetLibraryClassList():
840            Tmp = LibraryClassXml()
841            LibraryClassNode.appendChild(Tmp.ToXml2(LibraryClass, 'LibraryClass'))
842        DomModule.appendChild(LibraryClassNode)
843        #
844        # SourceFile
845        #
846        SourceFileNode = CreateXmlElement('SourceFiles', '', [], [])
847        for SourceFile in Module.GetSourceFileList():
848            Tmp = SourceFileXml()
849            SourceFileNode.appendChild(Tmp.ToXml(SourceFile, 'Filename'))
850        DomModule.appendChild(SourceFileNode)
851        #
852        # BinaryFile
853        #
854        BinaryFileNode = CreateXmlElement('BinaryFiles', '', [], [])
855        for BinaryFile in Module.GetBinaryFileList():
856            Tmp = BinaryFileXml()
857            BinaryFileNode.appendChild(Tmp.ToXml(BinaryFile, 'BinaryFile'))
858        DomModule.appendChild(BinaryFileNode)
859        #
860        # PackageDependencies
861        #
862        PackageDependencyNode = CreateXmlElement('PackageDependencies', '', [], [])
863        for PackageDependency in Module.GetPackageDependencyList():
864            Tmp = PackageXml()
865            PackageDependencyNode.appendChild(Tmp.ToXml(PackageDependency, 'Package'))
866        DomModule.appendChild(PackageDependencyNode)
867
868        #
869        # Guid
870        #
871        GuidProtocolPpiNode = CreateXmlElement('Guids', '', [], [])
872        for GuidProtocolPpi in Module.GetGuidList():
873            Tmp = GuidXml('Module')
874            GuidProtocolPpiNode.appendChild(Tmp.ToXml(GuidProtocolPpi, 'GuidCName'))
875        DomModule.appendChild(GuidProtocolPpiNode)
876
877        #
878        # Protocol
879        #
880        GuidProtocolPpiNode = CreateXmlElement('Protocols', '', [], [])
881        for GuidProtocolPpi in Module.GetProtocolList():
882            Tmp = ProtocolXml('Module')
883            GuidProtocolPpiNode.appendChild(Tmp.ToXml(GuidProtocolPpi, 'Protocol'))
884        DomModule.appendChild(GuidProtocolPpiNode)
885
886        #
887        # Ppi
888        #
889        GuidProtocolPpiNode = CreateXmlElement('PPIs', '', [], [])
890        for GuidProtocolPpi in Module.GetPpiList():
891            Tmp = PpiXml('Module')
892            GuidProtocolPpiNode.appendChild(Tmp.ToXml(GuidProtocolPpi, 'Ppi'))
893        DomModule.appendChild(GuidProtocolPpiNode)
894        #
895        # Extern
896        #
897        ExternNode = CreateXmlElement('Externs', '', [], [])
898        for Extern in Module.GetExternList():
899            Tmp = ExternXml()
900            ExternNode.appendChild(Tmp.ToXml(Extern, 'Extern'))
901        DomModule.appendChild(ExternNode)
902        #
903        # PcdCoded
904        #
905        PcdEntryNode = CreateXmlElement('PcdCoded', '', [], [])
906        for PcdEntry in Module.GetPcdList():
907            Tmp = PcdEntryXml()
908            PcdEntryNode.appendChild(Tmp.ToXml3(PcdEntry, 'PcdEntry'))
909        DomModule.appendChild(PcdEntryNode)
910
911        #
912        # PeiDepex
913        #
914        if Module.GetPeiDepex():
915            for Item in Module.GetPeiDepex():
916                Tmp = DepexXml()
917                DomModule.appendChild(Tmp.ToXml(Item, 'PeiDepex'))
918
919        #
920        # DxeDepex
921        #
922        if Module.GetDxeDepex():
923            for Item in Module.GetDxeDepex():
924                Tmp = DepexXml()
925                DomModule.appendChild(Tmp.ToXml(Item, 'DxeDepex'))
926
927        #
928        # SmmDepex
929        #
930        if Module.GetSmmDepex():
931            for Item in Module.GetSmmDepex():
932                Tmp = DepexXml()
933                DomModule.appendChild(Tmp.ToXml(Item, 'SmmDepex'))
934
935        #
936        # MiscellaneousFile
937        #
938        if Module.GetMiscFileList():
939            Tmp = MiscellaneousFileXml()
940            DomModule.appendChild(Tmp.ToXml(Module.GetMiscFileList()[0], 'MiscellaneousFiles'))
941        #
942        # UserExtensions
943        #
944        if Module.GetUserExtensionList():
945            for UserExtension in Module.GetUserExtensionList():
946                Tmp = UserExtensionsXml()
947                DomModule.appendChild(Tmp.ToXml(UserExtension, 'UserExtensions'))
948
949        return DomModule
950
951##
952# BuildFlagXml used to generate BuildFlag for <AsBuilt>
953#
954class BuildFlagXml(object):
955    def __init__(self):
956        self.Target = ''
957        self.TagName = ''
958        self.Family = ''
959        self.AsBuiltFlags = ''
960
961    def FromXml(self, Item, Key):
962        self.Target = XmlElement(Item, '%s/Target' % Key)
963        self.TagName = XmlElement(Item, '%s/TagName' % Key)
964        self.Family = XmlElement(Item, '%s/Family' % Key)
965
966        BuildFlag = BinaryBuildFlagObject()
967
968        BuildFlag.SetTarget(self.Target)
969        BuildFlag.SetTagName(self.TagName)
970        BuildFlag.SetFamily(self.Family)
971
972        return BuildFlag
973
974    #
975    # For AsBuild INF usage
976    #
977    def FromXml2(self, Item, Key):
978        self.AsBuiltFlags = XmlElement(Item, '%s' % Key)
979
980        LineList = GetSplitValueList(self.AsBuiltFlags, '\n')
981        ReturnLine = ''
982        Count = 0
983        for Line in LineList:
984            if Count == 0:
985                ReturnLine = "# " + Line
986            else:
987                ReturnLine = ReturnLine + '\n' + '# ' + Line
988            Count += 1
989
990        BuildFlag = BinaryBuildFlagObject()
991        BuildFlag.SetAsBuiltOptionFlags(ReturnLine)
992
993        return BuildFlag
994
995    def ToXml(self, BuildFlag, Key):
996        if self.Target:
997            pass
998        AttributeList = []
999        NodeList = []
1000        NodeList.append(['BuildFlags', BuildFlag])
1001
1002        Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
1003        return Root
1004