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