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