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