1## @file
2# This file is used to parse a PCD 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'''
10CommonXml
11'''
12
13##
14# Import Modules
15#
16
17from Core.DistributionPackageClass import DistributionPackageHeaderObject
18from Library.StringUtils import ConvertNEToNOTEQ
19from Library.StringUtils import ConvertNOTEQToNE
20from Library.StringUtils import GetSplitValueList
21from Library.StringUtils import GetStringOfList
22from Library.Xml.XmlRoutines import XmlElement
23from Library.Xml.XmlRoutines import XmlElement2
24from Library.Xml.XmlRoutines import XmlAttribute
25from Library.Xml.XmlRoutines import XmlNode
26from Library.Xml.XmlRoutines import XmlList
27from Library.Xml.XmlRoutines import CreateXmlElement
28from Library.UniClassObject import ConvertSpecialUnicodes
29from Library.UniClassObject import GetLanguageCode1766
30from Object.POM.CommonObject import FileObject
31from Object.POM.CommonObject import MiscFileObject
32from Object.POM.CommonObject import UserExtensionObject
33from Object.POM.CommonObject import ClonedRecordObject
34from Object.POM.CommonObject import LibraryClassObject
35from Object.POM.CommonObject import FileNameObject
36from Object.POM.ModuleObject import ModuleObject
37from Xml.XmlParserMisc import IsRequiredItemListNull
38from Xml.XmlParserMisc import GetHelpTextList
39import Library.DataType as DataType
40
41##
42# ClonedFromXml
43#
44class ClonedFromXml(object):
45    def __init__(self):
46        self.GUID = ''
47        self.Version = ''
48
49    def FromXml(self, Item, Key):
50        self.GUID = XmlElement(Item, '%s/GUID' % Key)
51        self.Version = XmlAttribute(XmlNode(Item, '%s/GUID' % Key), 'Version')
52        if self.GUID == '' and self.Version == '':
53            return None
54        ClonedFrom = ClonedRecordObject()
55        ClonedFrom.SetPackageGuid(self.GUID)
56        ClonedFrom.SetPackageVersion(self.Version)
57        return ClonedFrom
58
59    def ToXml(self, ClonedFrom, Key):
60        if self.GUID:
61            pass
62        Element1 = CreateXmlElement('GUID', ClonedFrom.GetPackageGuid(), [],
63                                    [['Version', ClonedFrom.GetPackageVersion()]])
64        AttributeList = []
65        NodeList = [Element1]
66        Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
67        return Root
68
69    def __str__(self):
70        return "GUID = %s Version = %s" % (self.GUID, self.Version)
71
72
73##
74# CommonDefinesXml
75#
76class CommonDefinesXml(object):
77    def __init__(self):
78        self.Usage = ''
79        self.SupArchList = []
80        self.SupModList = []
81        self.FeatureFlag = ''
82
83    def FromXml(self, Item, Key):
84        if Key:
85            pass
86        self.Usage = XmlAttribute(Item, 'Usage')
87        self.SupArchList = \
88        [Arch for Arch in GetSplitValueList(XmlAttribute(Item, 'SupArchList'), DataType.TAB_SPACE_SPLIT) if Arch]
89        self.SupModList = \
90        [Mod for Mod in GetSplitValueList(XmlAttribute(Item, 'SupModList'), DataType.TAB_SPACE_SPLIT) if Mod]
91        self.FeatureFlag = ConvertNOTEQToNE(XmlAttribute(Item, 'FeatureFlag'))
92
93    def ToXml(self):
94        pass
95
96    def __str__(self):
97        return "Usage = %s SupArchList = %s SupModList = %s FeatureFlag = %s" \
98                % (self.Usage, self.SupArchList, self.SupModList, self.FeatureFlag)
99
100##
101# PromptXml
102#
103class PromptXml(object):
104    def __init__(self):
105        self.Prompt = ''
106        self.Lang = ''
107
108    def FromXml(self, Item, Key):
109        if Key:
110            pass
111        self.Prompt = XmlElement2(Item, 'Prompt')
112        self.Lang = XmlAttribute(Item, 'Lang')
113
114    def ToXml(self, Prompt, Key='Prompt'):
115        if self.Prompt:
116            pass
117        return CreateXmlElement('%s' % Key, Prompt.GetString(), [], [['Lang', Prompt.GetLang()]])
118    def __str__(self):
119        return "Prompt = %s Lang = %s" % (self.Prompt, self.Lang)
120
121##
122# HelpTextXml
123#
124class HelpTextXml(object):
125    def __init__(self):
126        self.HelpText = ''
127        self.Lang = ''
128
129    def FromXml(self, Item, Key):
130        if Key:
131            pass
132        self.HelpText = XmlElement2(Item, 'HelpText')
133        self.Lang = XmlAttribute(Item, 'Lang')
134
135    def ToXml(self, HelpText, Key='HelpText'):
136        if self.HelpText:
137            pass
138        return CreateXmlElement('%s' % Key, HelpText.GetString(), [], [['Lang', HelpText.GetLang()]])
139    def __str__(self):
140        return "HelpText = %s Lang = %s" % (self.HelpText, self.Lang)
141
142##
143# HeaderXml
144#
145class HeaderXml(object):
146    def __init__(self):
147        self.Name = ''
148        self.BaseName = ''
149        self.GUID = ''
150        self.Version = ''
151        self.CopyrightList = []
152        self.LicenseList = []
153        self.AbstractList = []
154        self.DescriptionList = []
155
156    def FromXml(self, Item, Key, IsRequiredCheck=False, IsStandAlongModule=False):
157        if not Item and IsRequiredCheck:
158            XmlTreeLevel = []
159            if IsStandAlongModule:
160                XmlTreeLevel = ['DistributionPackage', 'ModuleSurfaceArea']
161            else:
162                XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'ModuleSurfaceArea']
163            CheckDict = {'Header':''}
164            IsRequiredItemListNull(CheckDict, XmlTreeLevel)
165        self.Name = XmlElement(Item, '%s/Name' % Key)
166        self.BaseName = XmlAttribute(XmlNode(Item, '%s/Name' % Key), 'BaseName')
167        self.GUID = XmlElement(Item, '%s/GUID' % Key)
168        self.Version = XmlAttribute(XmlNode(Item, '%s/GUID' % Key), 'Version')
169
170        for SubItem in XmlList(Item, '%s/Abstract' % Key):
171            HeaderAbstractLang = XmlAttribute(SubItem, 'Lang')
172            self.AbstractList.append((HeaderAbstractLang, XmlElement(SubItem, '%s/Abstract' % Key)))
173        for SubItem in XmlList(Item, '%s/Description' % Key):
174            HeaderDescriptionLang = XmlAttribute(SubItem, 'Lang')
175            self.DescriptionList.append((HeaderDescriptionLang, XmlElement(SubItem, '%s/Description' % Key)))
176        for SubItem in XmlList(Item, '%s/Copyright' % Key):
177            HeaderCopyrightLang = XmlAttribute(SubItem, 'Lang')
178            self.CopyrightList.append((HeaderCopyrightLang, XmlElement(SubItem, '%s/Copyright' % Key)))
179        for SubItem in XmlList(Item, '%s/License' % Key):
180            HeaderLicenseLang = XmlAttribute(SubItem, 'Lang')
181            self.LicenseList.append((HeaderLicenseLang, XmlElement(SubItem, '%s/License' % Key)))
182        ModuleHeader = ModuleObject()
183        ModuleHeader.SetName(self.Name)
184        ModuleHeader.SetBaseName(self.BaseName)
185        ModuleHeader.SetGuid(self.GUID)
186        ModuleHeader.SetVersion(self.Version)
187        ModuleHeader.SetCopyright(self.CopyrightList)
188        ModuleHeader.SetLicense(self.LicenseList)
189        ModuleHeader.SetAbstract(self.AbstractList)
190        ModuleHeader.SetDescription(self.DescriptionList)
191        return ModuleHeader
192
193    def ToXml(self, Header, Key):
194        if self.GUID:
195            pass
196        Element1 = CreateXmlElement('Name', Header.GetName(), [], [['BaseName', Header.GetBaseName()]])
197        Element2 = CreateXmlElement('GUID', Header.GetGuid(), [], [['Version', Header.GetVersion()]])
198        NodeList = [Element1,
199                    Element2,
200                    ]
201
202        UNIInfAbstractList = []
203        UNIInfDescriptionList = []
204        # Get Abstract and Description from Uni File
205        # if the Uni File exists
206        if Header.UniFileClassObject is not None:
207            UniStrDict = Header.UniFileClassObject.OrderedStringList
208            for Lang in UniStrDict:
209                for StringDefClassObject in UniStrDict[Lang]:
210                    if not StringDefClassObject.StringValue:
211                        continue
212                    if StringDefClassObject.StringName == DataType.TAB_INF_ABSTRACT:
213                        UNIInfAbstractList.append((GetLanguageCode1766(Lang),
214                                                   ConvertSpecialUnicodes(StringDefClassObject.StringValue)))
215
216                    if StringDefClassObject.StringName == DataType.TAB_INF_DESCRIPTION:
217                        UNIInfDescriptionList.append((GetLanguageCode1766(Lang),
218                                                      ConvertSpecialUnicodes(StringDefClassObject.StringValue)))
219
220        # Get Abstract and Description from INF File Header
221        for (Lang, Value) in Header.GetCopyright():
222            if Value:
223                NodeList.append(CreateXmlElement('Copyright', Value, [], []))
224        for (Lang, Value) in Header.GetLicense():
225            if Value:
226                NodeList.append(CreateXmlElement('License', Value, [], []))
227        for (Lang, Value) in Header.GetAbstract() + UNIInfAbstractList:
228            if Value:
229                NodeList.append(CreateXmlElement('Abstract', Value, [], [['Lang', Lang]]))
230        for (Lang, Value) in Header.GetDescription() + UNIInfDescriptionList:
231            if Value:
232                NodeList.append(CreateXmlElement('Description', Value, [], [['Lang', Lang]]))
233
234        AttributeList = []
235        Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
236        return Root
237
238    def __str__(self):
239        return "Name = %s BaseName = %s GUID = %s Version = %s Copyright = %s \
240        License = %s Abstract = %s Description = %s" % \
241        (self.Name, self.BaseName, self.GUID, self.Version, self.CopyrightList, \
242         self.LicenseList, self.AbstractList, self.DescriptionList)
243##
244# DistributionPackageHeaderXml
245#
246class DistributionPackageHeaderXml(object):
247    def __init__(self):
248        self.Header = HeaderXml()
249        self.ReadOnly = ''
250        self.RePackage = ''
251        self.Vendor = ''
252        self.Date = ''
253        self.Signature = ''
254        self.XmlSpecification = ''
255
256    def FromXml(self, Item, Key):
257        if not Item:
258            return None
259        self.ReadOnly = XmlAttribute(XmlNode(Item, '%s' % Key), 'ReadOnly')
260        self.RePackage = XmlAttribute(XmlNode(Item, '%s' % Key), 'RePackage')
261        self.Vendor = XmlElement(Item, '%s/Vendor' % Key)
262        self.Date = XmlElement(Item, '%s/Date' % Key)
263        self.Signature = XmlElement(Item, '%s/Signature' % Key)
264        self.XmlSpecification = XmlElement(Item, '%s/XmlSpecification' % Key)
265        self.Header.FromXml(Item, Key)
266        DistributionPackageHeader = DistributionPackageHeaderObject()
267        if self.ReadOnly.upper() == 'TRUE':
268            DistributionPackageHeader.ReadOnly = True
269        elif self.ReadOnly.upper() == 'FALSE':
270            DistributionPackageHeader.ReadOnly = False
271        if self.RePackage.upper() == 'TRUE':
272            DistributionPackageHeader.RePackage = True
273        elif self.RePackage.upper() == 'FALSE':
274            DistributionPackageHeader.RePackage = False
275        DistributionPackageHeader.Vendor = self.Vendor
276        DistributionPackageHeader.Date = self.Date
277        DistributionPackageHeader.Signature = self.Signature
278        DistributionPackageHeader.XmlSpecification = self.XmlSpecification
279        DistributionPackageHeader.SetName(self.Header.Name)
280        DistributionPackageHeader.SetBaseName(self.Header.BaseName)
281        DistributionPackageHeader.SetGuid(self.Header.GUID)
282        DistributionPackageHeader.SetVersion(self.Header.Version)
283        DistributionPackageHeader.SetCopyright(self.Header.CopyrightList)
284        DistributionPackageHeader.SetLicense(self.Header.LicenseList)
285        DistributionPackageHeader.SetAbstract(self.Header.AbstractList)
286        DistributionPackageHeader.SetDescription(self.Header.DescriptionList)
287        return DistributionPackageHeader
288
289    def ToXml(self, DistributionPackageHeader, Key):
290        if self.Header:
291            pass
292        Element1 = CreateXmlElement('Name', \
293                                    DistributionPackageHeader.GetName(), [], \
294                                    [['BaseName', \
295                                    DistributionPackageHeader.GetBaseName()]])
296        Element2 = CreateXmlElement('GUID', \
297                                    DistributionPackageHeader.GetGuid(), [], \
298                                    [['Version', \
299                                    DistributionPackageHeader.GetVersion()]])
300        AttributeList = []
301        if DistributionPackageHeader.ReadOnly != '':
302            AttributeList.append(['ReadOnly', str(DistributionPackageHeader.ReadOnly).lower()])
303        if DistributionPackageHeader.RePackage != '':
304            AttributeList.append(['RePackage', str(DistributionPackageHeader.RePackage).lower()])
305        if DistributionPackageHeader.GetAbstract():
306            DPAbstract = DistributionPackageHeader.GetAbstract()[0][1]
307        else:
308            DPAbstract = ''
309        if DistributionPackageHeader.GetDescription():
310            DPDescription = DistributionPackageHeader.GetDescription()[0][1]
311        else:
312            DPDescription = ''
313        if DistributionPackageHeader.GetCopyright():
314            DPCopyright = DistributionPackageHeader.GetCopyright()[0][1]
315        else:
316            DPCopyright = ''
317        if DistributionPackageHeader.GetLicense():
318            DPLicense = DistributionPackageHeader.GetLicense()[0][1]
319        else:
320            DPLicense = ''
321        NodeList = [Element1,
322                    Element2,
323                    ['Vendor', DistributionPackageHeader.Vendor],
324                    ['Date', DistributionPackageHeader.Date],
325                    ['Copyright', DPCopyright],
326                    ['License', DPLicense],
327                    ['Abstract', DPAbstract],
328                    ['Description', DPDescription],
329                    ['Signature', DistributionPackageHeader.Signature],
330                    ['XmlSpecification', \
331                     DistributionPackageHeader.XmlSpecification],
332                    ]
333        Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
334        return Root
335
336    def __str__(self):
337        return "ReadOnly = %s RePackage = %s Vendor = %s Date = %s \
338        Signature = %s XmlSpecification = %s %s" % \
339        (self.ReadOnly, self.RePackage, self.Vendor, self.Date, \
340         self.Signature, self.XmlSpecification, self.Header)
341##
342# PackageHeaderXml
343#
344class PackageHeaderXml(object):
345    def __init__(self):
346        self.Header = HeaderXml()
347        self.PackagePath = ''
348
349    def FromXml(self, Item, Key, PackageObject2):
350        if not Item:
351            XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea']
352            CheckDict = {'PackageHeader': None, }
353            IsRequiredItemListNull(CheckDict, XmlTreeLevel)
354        self.PackagePath = XmlElement(Item, '%s/PackagePath' % Key)
355        self.Header.FromXml(Item, Key)
356        PackageObject2.SetName(self.Header.Name)
357        PackageObject2.SetBaseName(self.Header.BaseName)
358        PackageObject2.SetGuid(self.Header.GUID)
359        PackageObject2.SetVersion(self.Header.Version)
360        PackageObject2.SetCopyright(self.Header.CopyrightList)
361        PackageObject2.SetLicense(self.Header.LicenseList)
362        PackageObject2.SetAbstract(self.Header.AbstractList)
363        PackageObject2.SetDescription(self.Header.DescriptionList)
364        PackageObject2.SetPackagePath(self.PackagePath)
365
366    def ToXml(self, PackageObject2, Key):
367        if self.PackagePath:
368            pass
369        Element1 = CreateXmlElement('Name', PackageObject2.GetName(), [], \
370                         [['BaseName', PackageObject2.GetBaseName()]])
371        Element2 = CreateXmlElement('GUID', PackageObject2.GetGuid(), [], \
372                                    [['Version', PackageObject2.GetVersion()]])
373        NodeList = [Element1,
374                    Element2
375                    ]
376
377        UNIPackageAbrstractList = []
378        UNIPackageDescriptionList = []
379        # Get Abstract and Description from Uni File
380        # if the Uni File exists
381        if PackageObject2.UniFileClassObject is not None:
382            UniStrDict = PackageObject2.UniFileClassObject.OrderedStringList
383            for Lang in UniStrDict:
384                for StringDefClassObject in UniStrDict[Lang]:
385                    if not StringDefClassObject.StringValue:
386                        continue
387                    if StringDefClassObject.StringName == DataType.TAB_DEC_PACKAGE_ABSTRACT:
388                        UNIPackageAbrstractList.append((GetLanguageCode1766(Lang),
389                                                        ConvertSpecialUnicodes(StringDefClassObject.StringValue)))
390
391                    if StringDefClassObject.StringName == DataType.TAB_DEC_PACKAGE_DESCRIPTION:
392                        UNIPackageDescriptionList.append((GetLanguageCode1766(Lang),
393                                                          ConvertSpecialUnicodes(StringDefClassObject.StringValue)))
394
395        # Get Abstract and Description from DEC File Header
396        for (Lang, Value) in PackageObject2.GetCopyright():
397            if Value:
398                NodeList.append(CreateXmlElement(DataType.TAB_HEADER_COPYRIGHT, Value, [], []))
399        for (Lang, Value) in PackageObject2.GetLicense():
400            if Value:
401                NodeList.append(CreateXmlElement(DataType.TAB_HEADER_LICENSE, Value, [], []))
402        for (Lang, Value) in PackageObject2.GetAbstract() + UNIPackageAbrstractList:
403            if Value:
404                NodeList.append(CreateXmlElement(DataType.TAB_HEADER_ABSTRACT, Value, [], [['Lang', Lang]]))
405        for (Lang, Value) in PackageObject2.GetDescription() + UNIPackageDescriptionList:
406            if Value:
407                NodeList.append(CreateXmlElement(DataType.TAB_HEADER_DESCRIPTION, Value, [], [['Lang', Lang]]))
408
409
410        NodeList.append(['PackagePath', PackageObject2.GetPackagePath()])
411        AttributeList = []
412        Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
413        return Root
414
415    def __str__(self):
416        return "PackagePath = %s %s" \
417               % (self.PackagePath, self.Header)
418
419##
420# MiscellaneousFileXml
421#
422class MiscellaneousFileXml(object):
423    def __init__(self):
424        self.Header = HeaderXml()
425        self.Files = []
426    ##
427    # This API is used for Package or Module's MiscellaneousFile section
428    #
429    def FromXml(self, Item, Key):
430        if not Item:
431            return None
432        self.Header.FromXml(Item, Key)
433        NewItem = XmlNode(Item, '%s/Header' % Key)
434        self.Header.FromXml(NewItem, 'Header')
435        for SubItem in XmlList(Item, '%s/Filename' % Key):
436            Filename = XmlElement(SubItem, '%s/Filename' % Key)
437            Executable = XmlAttribute(XmlNode(SubItem, '%s/Filename' % Key), 'Executable')
438            if Executable.upper() == "TRUE":
439                Executable = True
440            elif Executable.upper() == "FALSE":
441                Executable = False
442            else:
443                Executable = ''
444            self.Files.append([Filename, Executable])
445        MiscFile = MiscFileObject()
446        MiscFile.SetCopyright(self.Header.CopyrightList)
447        MiscFile.SetLicense(self.Header.LicenseList)
448        MiscFile.SetAbstract(self.Header.AbstractList)
449        MiscFile.SetDescription(self.Header.DescriptionList)
450        MiscFileList = []
451        for File in self.Files:
452            FileObj = FileObject()
453            FileObj.SetURI(File[0])
454            FileObj.SetExecutable(File[1])
455            MiscFileList.append(FileObj)
456        MiscFile.SetFileList(MiscFileList)
457        return MiscFile
458    ##
459    # This API is used for DistP's tool section
460    #
461    def FromXml2(self, Item, Key):
462        if Item is None:
463            return None
464        NewItem = XmlNode(Item, '%s/Header' % Key)
465        self.Header.FromXml(NewItem, 'Header')
466        for SubItem in XmlList(Item, '%s/Filename' % Key):
467            Filename = XmlElement(SubItem, '%s/Filename' % Key)
468            Executable = \
469            XmlAttribute(XmlNode(SubItem, '%s/Filename' % Key), 'Executable')
470            OsType = XmlAttribute(XmlNode(SubItem, '%s/Filename' % Key), 'OS')
471            if Executable.upper() == "TRUE":
472                Executable = True
473            elif Executable.upper() == "FALSE":
474                Executable = False
475            else:
476                Executable = ''
477            self.Files.append([Filename, Executable, OsType])
478        MiscFile = MiscFileObject()
479        MiscFile.SetName(self.Header.Name)
480        MiscFile.SetCopyright(self.Header.CopyrightList)
481        MiscFile.SetLicense(self.Header.LicenseList)
482        MiscFile.SetAbstract(self.Header.AbstractList)
483        MiscFile.SetDescription(self.Header.DescriptionList)
484        MiscFileList = []
485        for File in self.Files:
486            FileObj = FileObject()
487            FileObj.SetURI(File[0])
488            FileObj.SetExecutable(File[1])
489            FileObj.SetOS(File[2])
490            MiscFileList.append(FileObj)
491        MiscFile.SetFileList(MiscFileList)
492        return MiscFile
493
494    ##
495    # This API is used for Package or Module's MiscellaneousFile section
496    #
497    def ToXml(self, MiscFile, Key):
498        if self.Header:
499            pass
500        if MiscFile:
501            if MiscFile.GetAbstract():
502                DPAbstract = MiscFile.GetAbstract()[0][1]
503            else:
504                DPAbstract = ''
505            if MiscFile.GetDescription():
506                DPDescription = MiscFile.GetDescription()[0][1]
507            else:
508                DPDescription = ''
509            if MiscFile.GetCopyright():
510                DPCopyright = MiscFile.GetCopyright()[0][1]
511            else:
512                DPCopyright = ''
513            if MiscFile.GetLicense():
514                DPLicense = MiscFile.GetLicense()[0][1]
515            else:
516                DPLicense = ''
517            NodeList = [['Copyright', DPCopyright],
518                        ['License', DPLicense],
519                        ['Abstract', DPAbstract],
520                        ['Description', DPDescription],
521                       ]
522            for File in MiscFile.GetFileList():
523                NodeList.append\
524                (CreateXmlElement\
525                 ('Filename', File.GetURI(), [], \
526                  [['Executable', str(File.GetExecutable()).lower()]]))
527            Root = CreateXmlElement('%s' % Key, '', NodeList, [])
528            return Root
529    ##
530    # This API is used for DistP's tool section
531    #
532    def ToXml2(self, MiscFile, Key):
533        if self.Header:
534            pass
535        if MiscFile:
536            if MiscFile.GetAbstract():
537                DPAbstract = MiscFile.GetAbstract()[0][1]
538            else:
539                DPAbstract = ''
540            if MiscFile.GetDescription():
541                DPDescription = MiscFile.GetDescription()[0][1]
542            else:
543                DPDescription = ''
544            if MiscFile.GetCopyright():
545                DPCopyright = MiscFile.GetCopyright()[0][1]
546            else:
547                DPCopyright = ''
548            if MiscFile.GetLicense():
549                DPLicense = MiscFile.GetLicense()[0][1]
550            else:
551                DPLicense = ''
552            NodeList = [['Name', MiscFile.GetName()],
553                        ['Copyright', DPCopyright],
554                        ['License', DPLicense],
555                        ['Abstract', DPAbstract],
556                        ['Description', DPDescription],
557                       ]
558            HeaderNode = CreateXmlElement('Header', '', NodeList, [])
559            NodeList = [HeaderNode]
560            for File in MiscFile.GetFileList():
561                NodeList.append\
562                (CreateXmlElement\
563                 ('Filename', File.GetURI(), [], \
564                  [['Executable', str(File.GetExecutable()).lower()], \
565                   ['OS', File.GetOS()]]))
566            Root = CreateXmlElement('%s' % Key, '', NodeList, [])
567            return Root
568
569    def __str__(self):
570        Str = str(self.Header)
571        for Item in self.Files:
572            Str = Str + '\n\tFilename:' + str(Item)
573        return Str
574##
575# UserExtensionsXml
576#
577class UserExtensionsXml(object):
578    def __init__(self):
579        self.UserId = ''
580        self.Identifier = ''
581        self.BinaryAbstractList = []
582        self.BinaryDescriptionList = []
583        self.BinaryCopyrightList = []
584        self.BinaryLicenseList = []
585        self.LangDefsList = []
586        self.DefineDict = {}
587        self.BuildOptionDict = {}
588        self.IncludesDict = {}
589        self.SourcesDict = {}
590        self.BinariesDict = {}
591        self.SupArchList = []
592        self.Statement = ''
593        self.Defines = ''
594        self.BuildOptions = ''
595
596    def FromXml2(self, Item, Key):
597        self.UserId = XmlAttribute(XmlNode(Item, '%s' % Key), 'UserId')
598        self.Identifier = XmlAttribute(XmlNode(Item, '%s' % Key), 'Identifier')
599        UserExtension = UserExtensionObject()
600        UserExtension.SetUserID(self.UserId)
601        UserExtension.SetIdentifier(self.Identifier)
602        return UserExtension
603
604    def FromXml(self, Item, Key):
605        self.UserId = XmlAttribute(XmlNode(Item, '%s' % Key), 'UserId')
606        self.Identifier = XmlAttribute(XmlNode(Item, '%s' % Key), 'Identifier')
607        if self.UserId == DataType.TAB_BINARY_HEADER_USERID \
608        and self.Identifier == DataType.TAB_BINARY_HEADER_IDENTIFIER:
609            for SubItem in XmlList(Item, '%s/BinaryAbstract' % Key):
610                BinaryAbstractLang = XmlAttribute(SubItem, 'Lang')
611                self.BinaryAbstractList.append((BinaryAbstractLang, XmlElement(SubItem, '%s/BinaryAbstract' % Key)))
612            for SubItem in XmlList(Item, '%s/BinaryDescription' % Key):
613                BinaryDescriptionLang = XmlAttribute(SubItem, 'Lang')
614                self.BinaryDescriptionList.append((BinaryDescriptionLang,
615                                                       XmlElement(SubItem, '%s/BinaryDescription' % Key)))
616            for SubItem in XmlList(Item, '%s/BinaryCopyright' % Key):
617                BinaryCopyrightLang = XmlAttribute(SubItem, 'Lang')
618                self.BinaryCopyrightList.append((BinaryCopyrightLang,
619                                                     XmlElement(SubItem, '%s/BinaryCopyright' % Key)))
620            for SubItem in XmlList(Item, '%s/BinaryLicense' % Key):
621                BinaryLicenseLang = XmlAttribute(SubItem, 'Lang')
622                self.BinaryLicenseList.append((BinaryLicenseLang,
623                                                   XmlElement(SubItem, '%s/BinaryLicense' % Key)))
624
625        DefineItem = XmlNode(Item, '%s/Define' % Key)
626        for SubItem in XmlList(DefineItem, 'Define/Statement'):
627            Statement = XmlElement(SubItem, '%s/Statement' % Key)
628            self.DefineDict[Statement] = ""
629        BuildOptionItem = XmlNode(Item, '%s/BuildOption' % Key)
630        for SubItem in XmlList(BuildOptionItem, 'BuildOption/Statement'):
631            Statement = XmlElement(SubItem, '%s/Statement' % Key)
632            Arch = XmlAttribute(XmlNode(SubItem, '%s/Statement' % Key), 'SupArchList')
633            self.BuildOptionDict[Arch] = Statement
634        IncludesItem = XmlNode(Item, '%s/Includes' % Key)
635        for SubItem in XmlList(IncludesItem, 'Includes/Statement'):
636            Statement = XmlElement(SubItem, '%s/Statement' % Key)
637            Arch = XmlAttribute(XmlNode(SubItem, '%s/Statement' % Key), 'SupArchList')
638            self.IncludesDict[Statement] = Arch
639        SourcesItem = XmlNode(Item, '%s/Sources' % Key)
640        Tmp = UserExtensionSourceXml()
641        SourceDict = Tmp.FromXml(SourcesItem, 'Sources')
642        self.SourcesDict = SourceDict
643        BinariesItem = XmlNode(Item, '%s/Binaries' % Key)
644        Tmp = UserExtensionBinaryXml()
645        BinariesDict = Tmp.FromXml(BinariesItem, 'Binaries')
646        self.BinariesDict = BinariesDict
647        self.Statement = XmlElement(Item, 'UserExtensions')
648        SupArch = XmlAttribute(XmlNode(Item, '%s' % Key), 'SupArchList')
649        self.SupArchList = [Arch for Arch in GetSplitValueList(SupArch, DataType.TAB_SPACE_SPLIT) if Arch]
650        UserExtension = UserExtensionObject()
651        UserExtension.SetUserID(self.UserId)
652        UserExtension.SetIdentifier(self.Identifier)
653        UserExtension.SetBinaryAbstract(self.BinaryAbstractList)
654        UserExtension.SetBinaryDescription(self.BinaryDescriptionList)
655        UserExtension.SetBinaryCopyright(self.BinaryCopyrightList)
656        UserExtension.SetBinaryLicense(self.BinaryLicenseList)
657        UserExtension.SetStatement(self.Statement)
658        UserExtension.SetSupArchList(self.SupArchList)
659        UserExtension.SetDefinesDict(self.DefineDict)
660        UserExtension.SetBuildOptionDict(self.BuildOptionDict)
661        UserExtension.SetIncludesDict(self.IncludesDict)
662        UserExtension.SetSourcesDict(self.SourcesDict)
663        UserExtension.SetBinariesDict(self.BinariesDict)
664        return UserExtension
665
666    def ToXml(self, UserExtension, Key):
667        if self.UserId:
668            pass
669        AttributeList = [['UserId', str(UserExtension.GetUserID())],
670                         ['Identifier', str(UserExtension.GetIdentifier())],
671                         ['SupArchList', \
672                          GetStringOfList(UserExtension.GetSupArchList())],
673                        ]
674        Root = CreateXmlElement('%s' % Key, UserExtension.GetStatement(), [], \
675                                    AttributeList)
676        if UserExtension.GetIdentifier() == DataType.TAB_BINARY_HEADER_IDENTIFIER and \
677        UserExtension.GetUserID() == DataType.TAB_BINARY_HEADER_USERID:
678            for (Lang, Value) in UserExtension.GetBinaryAbstract():
679                if Value:
680                    ChildElement = CreateXmlElement('BinaryAbstract', Value, [], [['Lang', Lang]])
681                    Root.appendChild(ChildElement)
682            for (Lang, Value) in UserExtension.GetBinaryDescription():
683                if Value:
684                    ChildElement = CreateXmlElement('BinaryDescription', Value, [], [['Lang', Lang]])
685                    Root.appendChild(ChildElement)
686            for (Lang, Value) in UserExtension.GetBinaryCopyright():
687                if Value:
688                    ChildElement = CreateXmlElement('BinaryCopyright', Value, [], [])
689                    Root.appendChild(ChildElement)
690            for (Lang, Value) in UserExtension.GetBinaryLicense():
691                if Value:
692                    ChildElement = CreateXmlElement('BinaryLicense', Value, [], [])
693                    Root.appendChild(ChildElement)
694
695        NodeList = []
696        DefineDict = UserExtension.GetDefinesDict()
697        if DefineDict:
698            for Item in DefineDict.keys():
699                NodeList.append(CreateXmlElement\
700                                ('Statement', Item, [], []))
701            DefineElement = CreateXmlElement('Define', '', NodeList, [])
702            Root.appendChild(DefineElement)
703        NodeList = []
704        BuildOptionDict = UserExtension.GetBuildOptionDict()
705        if BuildOptionDict:
706            for Item in BuildOptionDict.keys():
707                NodeList.append(CreateXmlElement\
708                                ('Statement', BuildOptionDict[Item], [], \
709                                 [['SupArchList', Item]]))
710            BuildOptionElement = \
711            CreateXmlElement('BuildOption', '', NodeList, [])
712            Root.appendChild(BuildOptionElement)
713        NodeList = []
714        IncludesDict = UserExtension.GetIncludesDict()
715        if IncludesDict:
716            for Item in IncludesDict.keys():
717                NodeList.append(CreateXmlElement\
718                                ('Statement', Item, [], \
719                                 [['SupArchList', IncludesDict[Item]]]))
720            IncludesElement = CreateXmlElement('Includes', '', NodeList, [])
721            Root.appendChild(IncludesElement)
722        NodeList = []
723        SourcesDict = UserExtension.GetSourcesDict()
724        if SourcesDict:
725            Tmp = UserExtensionSourceXml()
726            Root.appendChild(Tmp.ToXml(SourcesDict, 'Sources'))
727        NodeList = []
728        BinariesDict = UserExtension.GetBinariesDict()
729        if BinariesDict:
730            Tmp = UserExtensionBinaryXml()
731            Root.appendChild(Tmp.ToXml(BinariesDict, 'Binaries'))
732        return Root
733
734    def __str__(self):
735        Str = "UserId = %s Identifier = %s" % (self.UserId, self.Identifier)
736        Str = Str + '\n\tDefines:' + str(self.Defines)
737        Str = Str + '\n\tBuildOptions:' + str(self.BuildOptions)
738        return Str
739
740##
741# UserExtensionSourceXml
742#
743class UserExtensionSourceXml(object):
744    def __init__(self):
745        self.UserExtensionSource = ''
746
747    def FromXml(self, Item, Key):
748        if Key:
749            pass
750        if self.UserExtensionSource:
751            pass
752        Dict = {}
753        #SourcesItem = XmlNode(Item, '%s/Sources' % Key)
754        for SubItem in XmlList(Item, 'Sources/SourceFile'):
755            FileName = XmlElement(SubItem, 'SourceFile/FileName')
756            Family = XmlElement(SubItem, 'SourceFile/Family')
757            FeatureFlag = XmlElement(SubItem, 'SourceFile/FeatureFlag')
758            SupArchStr = XmlElement(SubItem, 'SourceFile/SupArchList')
759            DictKey = (FileName, Family, FeatureFlag, SupArchStr)
760            ValueList = []
761            for ValueNodeItem in XmlList(SubItem, \
762                                         'SourceFile/SourceFileOtherAttr'):
763                TagName = XmlElement(ValueNodeItem, \
764                                     'SourceFileOtherAttr/TagName')
765                ToolCode = XmlElement(ValueNodeItem, \
766                                      'SourceFileOtherAttr/ToolCode')
767                Comment = XmlElement(ValueNodeItem, \
768                                     'SourceFileOtherAttr/Comment')
769                if (TagName == ' ') and (ToolCode == ' ') and (Comment == ' '):
770                    TagName = ''
771                    ToolCode = ''
772                    Comment = ''
773                ValueList.append((TagName, ToolCode, Comment))
774            Dict[DictKey] = ValueList
775        return Dict
776
777    def ToXml(self, Dict, Key):
778        if self.UserExtensionSource:
779            pass
780        SourcesNodeList = []
781        for Item in Dict:
782            ValueList = Dict[Item]
783            (FileName, Family, FeatureFlag, SupArchStr) = Item
784            SourceFileNodeList = []
785            SourceFileNodeList.append(["FileName", FileName])
786            SourceFileNodeList.append(["Family", Family])
787            SourceFileNodeList.append(["FeatureFlag", FeatureFlag])
788            SourceFileNodeList.append(["SupArchList", SupArchStr])
789            for (TagName, ToolCode, Comment) in ValueList:
790                ValueNodeList = []
791                if not (TagName or ToolCode or Comment):
792                    TagName = ' '
793                    ToolCode = ' '
794                    Comment = ' '
795                ValueNodeList.append(["TagName", TagName])
796                ValueNodeList.append(["ToolCode", ToolCode])
797                ValueNodeList.append(["Comment", Comment])
798                ValueNodeXml = CreateXmlElement('SourceFileOtherAttr', '', \
799                                                ValueNodeList, [])
800                SourceFileNodeList.append(ValueNodeXml)
801            SourceFileNodeXml = CreateXmlElement('SourceFile', '', \
802                                                 SourceFileNodeList, [])
803            SourcesNodeList.append(SourceFileNodeXml)
804        Root = CreateXmlElement('%s' % Key, '', SourcesNodeList, [])
805        return Root
806
807##
808# UserExtensionBinaryXml
809#
810class UserExtensionBinaryXml(object):
811    def __init__(self):
812        self.UserExtensionBinary = ''
813
814    def FromXml(self, Item, Key):
815        if Key:
816            pass
817        if self.UserExtensionBinary:
818            pass
819        Dict = {}
820        for SubItem in XmlList(Item, 'Binaries/Binary'):
821            FileName = XmlElement(SubItem, 'Binary/FileName')
822            FileType = XmlElement(SubItem, 'Binary/FileType')
823            FFE = XmlElement(SubItem, 'Binary/FeatureFlag')
824            SupArch = XmlElement(SubItem, 'Binary/SupArchList')
825            DictKey = (FileName, FileType, ConvertNOTEQToNE(FFE), SupArch)
826            ValueList = []
827            for ValueNodeItem in XmlList(SubItem, \
828                                         'Binary/BinaryFileOtherAttr'):
829                Target = XmlElement(ValueNodeItem, \
830                                    'BinaryFileOtherAttr/Target')
831                Family = XmlElement(ValueNodeItem, \
832                                    'BinaryFileOtherAttr/Family')
833                TagName = XmlElement(ValueNodeItem, \
834                                     'BinaryFileOtherAttr/TagName')
835                Comment = XmlElement(ValueNodeItem, \
836                                     'BinaryFileOtherAttr/Comment')
837                if (Target == ' ') and (Family == ' ') and \
838                   (TagName == ' ') and (Comment == ' '):
839                    Target = ''
840                    Family = ''
841                    TagName = ''
842                    Comment = ''
843
844                ValueList.append((Target, Family, TagName, Comment))
845            Dict[DictKey] = ValueList
846        return Dict
847
848    def ToXml(self, Dict, Key):
849        if self.UserExtensionBinary:
850            pass
851        BinariesNodeList = []
852        for Item in Dict:
853            ValueList = Dict[Item]
854            (FileName, FileType, FeatureFlag, SupArch) = Item
855            FileNodeList = []
856            FileNodeList.append(["FileName", FileName])
857            FileNodeList.append(["FileType", FileType])
858            FileNodeList.append(["FeatureFlag", ConvertNEToNOTEQ(FeatureFlag)])
859            FileNodeList.append(["SupArchList", SupArch])
860            for (Target, Family, TagName, Comment) in ValueList:
861                ValueNodeList = []
862                if not (Target or Family or TagName or Comment):
863                    Target = ' '
864                    Family = ' '
865                    TagName = ' '
866                    Comment = ' '
867                ValueNodeList.append(["Target", Target])
868                ValueNodeList.append(["Family", Family])
869                ValueNodeList.append(["TagName", TagName])
870                ValueNodeList.append(["Comment", Comment])
871                ValueNodeXml = CreateXmlElement('BinaryFileOtherAttr', '', \
872                                                ValueNodeList, [])
873                FileNodeList.append(ValueNodeXml)
874            FileNodeXml = CreateXmlElement('Binary', '', FileNodeList, [])
875            BinariesNodeList.append(FileNodeXml)
876        Root = CreateXmlElement('%s' % Key, '', BinariesNodeList, [])
877        return Root
878
879##
880# LibraryClassXml
881#
882class LibraryClassXml(object):
883    def __init__(self):
884        self.Keyword = ''
885        self.HeaderFile = ''
886        self.RecommendedInstanceGuid = ''
887        self.RecommendedInstanceVersion = ''
888        self.CommonDefines = CommonDefinesXml()
889        self.HelpText = []
890
891    def FromXml(self, Item, Key):
892        self.Keyword = XmlAttribute(XmlNode(Item, '%s' % Key), 'Keyword')
893        if self.Keyword == '':
894            self.Keyword = XmlElement(Item, '%s/Keyword' % Key)
895        self.HeaderFile = XmlElement(Item, '%s/HeaderFile' % Key)
896        self.CommonDefines.FromXml(XmlNode(Item, '%s' % Key), Key)
897        for HelpTextItem in XmlList(Item, '%s/HelpText' % Key):
898            HelpTextObj = HelpTextXml()
899            HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)
900            self.HelpText.append(HelpTextObj)
901        LibraryClass = LibraryClassObject()
902        LibraryClass.SetLibraryClass(self.Keyword)
903        LibraryClass.SetIncludeHeader(self.HeaderFile)
904        if self.CommonDefines.Usage:
905            LibraryClass.SetUsage(self.CommonDefines.Usage)
906        LibraryClass.SetSupArchList(self.CommonDefines.SupArchList)
907        LibraryClass.SetSupModuleList(self.CommonDefines.SupModList)
908        LibraryClass.SetFeatureFlag(ConvertNOTEQToNE(self.CommonDefines.FeatureFlag))
909        LibraryClass.SetHelpTextList(GetHelpTextList(self.HelpText))
910        return LibraryClass
911
912    def ToXml(self, LibraryClass, Key):
913        if self.HeaderFile:
914            pass
915        AttributeList = \
916        [['Keyword', LibraryClass.GetLibraryClass()],
917         ['SupArchList', GetStringOfList(LibraryClass.GetSupArchList())],
918         ['SupModList', GetStringOfList(LibraryClass.GetSupModuleList())]
919         ]
920        NodeList = [['HeaderFile', LibraryClass.GetIncludeHeader()]]
921        for Item in LibraryClass.GetHelpTextList():
922            Tmp = HelpTextXml()
923            NodeList.append(Tmp.ToXml(Item))
924        Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
925        return Root
926
927    def ToXml2(self, LibraryClass, Key):
928        if self.HeaderFile:
929            pass
930        FeatureFlag = ConvertNEToNOTEQ(LibraryClass.GetFeatureFlag())
931        AttributeList = \
932        [['Usage', LibraryClass.GetUsage()], \
933         ['SupArchList', GetStringOfList(LibraryClass.GetSupArchList())], \
934         ['SupModList', GetStringOfList(LibraryClass.GetSupModuleList())], \
935         ['FeatureFlag', FeatureFlag]
936         ]
937        NodeList = [['Keyword', LibraryClass.GetLibraryClass()], ]
938        for Item in LibraryClass.GetHelpTextList():
939            Tmp = HelpTextXml()
940            NodeList.append(Tmp.ToXml(Item))
941        Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
942        return Root
943
944    def __str__(self):
945        Str = "Keyword = %s HeaderFile = %s RecommendedInstanceGuid = %s RecommendedInstanceVersion = %s %s" % \
946              (self.Keyword, self.HeaderFile, self.RecommendedInstanceGuid, self.RecommendedInstanceVersion, \
947              self.CommonDefines)
948        for Item in self.HelpText:
949            Str = Str + "\n\t" + str(Item)
950        return Str
951
952##
953# FilenameXml
954#
955class FilenameXml(object):
956    def __init__(self):
957        self.FileType = ''
958        self.Filename = ''
959        self.CommonDefines = CommonDefinesXml()
960
961    def FromXml(self, Item, Key):
962        self.FileType = XmlAttribute(Item, 'FileType')
963        Guid = XmlAttribute(Item, 'GUID')
964        self.Filename = XmlElement(Item, 'Filename')
965        self.CommonDefines.FromXml(Item, Key)
966        FeatureFlag = ConvertNOTEQToNE(self.CommonDefines.FeatureFlag)
967        Filename = FileNameObject()
968        #
969        # Convert File Type
970        #
971        if self.FileType == 'UEFI_IMAGE':
972            self.FileType = 'PE32'
973
974        Filename.SetGuidValue(Guid)
975        Filename.SetFileType(self.FileType)
976        Filename.SetFilename(self.Filename)
977        Filename.SetSupArchList(self.CommonDefines.SupArchList)
978        Filename.SetFeatureFlag(FeatureFlag)
979
980        return Filename
981
982    def ToXml(self, Filename, Key):
983        if self.Filename:
984            pass
985        AttributeList = [['SupArchList', \
986                          GetStringOfList(Filename.GetSupArchList())],
987                         ['FileType', Filename.GetFileType()],
988                         ['FeatureFlag', ConvertNEToNOTEQ(Filename.GetFeatureFlag())],
989                         ['GUID', Filename.GetGuidValue()]
990                        ]
991        Root = CreateXmlElement('%s' % Key, Filename.GetFilename(), [], AttributeList)
992
993        return Root
994
995    def __str__(self):
996        return "FileType = %s Filename = %s %s" \
997             % (self.FileType, self.Filename, self.CommonDefines)
998