← Back to branch summary

~ubuntu-branches/ubuntu/trusty/virtualbox-lts-xenial/trusty-updates

« back to all changes in this revision

Viewing changes to src/VBox/Devices/EFI/Firmware/BaseTools/Source/Python/UPT/Xml/ModuleSurfaceAreaXml.py

  • Committer: Package Import Robot
  • Author(s): Gianfranco Costamagna
  • Date: 2016-02-23 14:28:26 UTC
  • Revision ID: package-import@ubuntu.com-20160223142826-bdu69el2z6wa2a44
Tags: upstream-4.3.36-dfsg
Import upstream version 4.3.36-dfsg

Show diffs side-by-side

added added

removed removed

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