]>
git.proxmox.com Git - mirror_edk2.git/blob - BaseTools/Source/Python/UPT/Xml/PcdXml.py
2 # This file is used to parse a PCD file of .PKG file
4 # Copyright (c) 2011 - 2014, Intel Corporation. All rights reserved.<BR>
6 # This program and the accompanying materials are licensed and made available
7 # under the terms and conditions of the BSD License which accompanies this
8 # distribution. The full text of the license may be found at
9 # http://opensource.org/licenses/bsd-license.php
11 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
23 from Library
.Xml
.XmlRoutines
import XmlElement
24 from Library
.Xml
.XmlRoutines
import XmlAttribute
25 from Library
.Xml
.XmlRoutines
import XmlNode
26 from Library
.Xml
.XmlRoutines
import CreateXmlElement
27 from Library
.Xml
.XmlRoutines
import XmlList
28 from Library
.String
import GetStringOfList
29 from Library
.String
import ConvertNEToNOTEQ
30 from Library
.String
import ConvertNOTEQToNE
31 from Library
import GlobalData
32 from Object
.POM
.CommonObject
import PcdObject
33 from Object
.POM
.CommonObject
import PcdErrorObject
34 from Xml
.CommonXml
import HelpTextXml
35 from Xml
.CommonXml
import PromptXml
36 from Xml
.CommonXml
import CommonDefinesXml
37 from Xml
.XmlParserMisc
import GetHelpTextList
38 from Xml
.XmlParserMisc
import GetPromptList
44 class PcdErrorXml(object):
46 self
.ValidValueList
= ''
47 self
.ValidValueListLang
= ''
48 self
.ValidValueRange
= ''
51 self
.ErrorMessage
= []
53 def FromXml(self
, Item
, Key
):
54 self
.ValidValueList
= XmlElement(Item
, '%s/ValidValueList' % Key
)
55 self
.ValidValueListLang
= \
56 XmlAttribute(XmlNode(Item
, '%s/ValidValueList' % Key
), 'Lang')
57 self
.ValidValueRange
= self
.TransferValidEpxr2ValidRange(XmlElement(Item
, '%s/ValidValueRange' % Key
))
58 self
.Expression
= XmlElement(Item
, '%s/Expression' % Key
)
59 self
.ErrorNumber
= XmlElement(Item
, '%s/ErrorNumber' % Key
)
60 for ErrMsg
in XmlList(Item
, '%s/ErrorMessage' % Key
):
61 ErrorMessageString
= XmlElement(ErrMsg
, 'ErrorMessage')
63 XmlAttribute(XmlNode(ErrMsg
, 'ErrorMessage'), 'Lang')
64 self
.ErrorMessage
.append((ErrorMessageLang
, ErrorMessageString
))
66 Error
= PcdErrorObject()
67 Error
.SetValidValue(self
.ValidValueList
)
68 Error
.SetValidValueLang(self
.ValidValueListLang
)
69 Error
.SetValidValueRange(self
.ValidValueRange
)
70 Error
.SetExpression(self
.Expression
)
71 Error
.SetErrorNumber(self
.ErrorNumber
)
72 Error
.SetErrorMessageList(self
.ErrorMessage
)
76 def ToXml(self
, PcdError
, Key
):
81 if PcdError
.GetValidValue():
83 CreateXmlElement('ValidValueList', PcdError
.GetValidValue(), [], \
84 [['Lang', PcdError
.GetValidValueLang()]])
85 NodeList
.append(Element1
)
86 if PcdError
.GetValidValueRange():
87 TansferedRangeStr
= self
.TransferValidRange2Expr(PcdError
.GetTokenSpaceGuidCName(),
89 PcdError
.GetValidValueRange())
91 CreateXmlElement('ValidValueRange', \
92 TansferedRangeStr
, [], [])
93 NodeList
.append(Element1
)
94 if PcdError
.GetExpression():
95 NodeList
.append(['Expression', PcdError
.GetExpression()])
96 if PcdError
.GetErrorNumber():
97 NodeList
.append(['ErrorNumber', PcdError
.GetErrorNumber()])
98 for Item
in PcdError
.GetErrorMessageList():
100 CreateXmlElement('ErrorMessage', Item
[1], [], [['Lang', Item
[0]]])
101 NodeList
.append(Element
)
102 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, AttributeList
)
106 def TransferValidRange2Expr(self
, TokenSpaceGuidCName
, CName
, ValidRange
):
109 INT_RANGE_PATTERN1
= '[\t\s]*[0-9]+[\t\s]*-[\t\s]*[0-9]+'
110 INT_RANGE_PATTERN2
= '[\t\s]*(LT|GT|LE|GE|XOR|EQ)[\t\s]+\d+[\t\s]*'
111 HEX_RANGE_PATTERN1
= \
112 '[\t\s]*0[xX][a-fA-F0-9]+[\t\s]*-[\t\s]*0[xX][a-fA-F0-9]+'
113 HEX_RANGE_PATTERN2
= '[\t\s]*(LT|GT|LE|GE|XOR|EQ)[\t\s]+0[xX][a-fA-F0-9]+[\t\s]*'
114 IntMatch1
= re
.compile(INT_RANGE_PATTERN1
)
115 IntMatch2
= re
.compile(INT_RANGE_PATTERN2
)
116 HexMatch1
= re
.compile(HEX_RANGE_PATTERN1
)
117 HexMatch2
= re
.compile(HEX_RANGE_PATTERN2
)
118 PcdName
= '.'.join([TokenSpaceGuidCName
, CName
])
122 # Convert HEX2 format range
125 for MatchObj
in HexMatch2
.finditer(ValidRange
):
126 MatchStr
= MatchObj
.group()
127 TransferedRangeStr
= ' '.join(['', PcdName
, MatchStr
.strip()])
128 ValidRange
= ValidRange
.replace(MatchStr
, TransferedRangeStr
)
130 # Convert INT2 format range
133 for MatchObj
in IntMatch2
.finditer(ValidRange
):
134 MatchStr
= MatchObj
.group()
135 TransferedRangeStr
= ' '.join(['', PcdName
, MatchStr
.strip()])
136 ValidRange
= ValidRange
.replace(MatchStr
, TransferedRangeStr
)
138 # Convert HEX1 format range
141 HexMatchedList
+= HexMatch1
.findall(ValidRange
)
143 for MatchStr
in HexMatchedList
:
144 RangeItemList
= MatchStr
.strip().split('-')
145 TransferedRangeStr
= '(%s GE %s) AND (%s LE %s)' % \
146 (PcdName
, RangeItemList
[0].strip(), PcdName
, RangeItemList
[1].strip())
147 ValidRange
= ValidRange
.replace(MatchStr
, TransferedRangeStr
)
149 # Convert INT1 format range
152 IntMatchedList
+= IntMatch1
.findall(ValidRange
)
154 for MatchStr
in IntMatchedList
:
155 RangeItemList
= MatchStr
.strip().split('-')
156 TransferedRangeStr
= '(%s GE %s) AND (%s LE %s)' % \
157 (PcdName
, RangeItemList
[0].strip(), PcdName
, RangeItemList
[1].strip())
158 ValidRange
= ValidRange
.replace(MatchStr
, TransferedRangeStr
)
162 def TransferValidEpxr2ValidRange(self
, ValidRangeExpr
):
167 '[\t\s]*[_a-zA-Z][a-zA-Z0-9_]*[\t\s]*\.[\t\s]*[_a-zA-Z][a-zA-Z0-9_]*[\t\s]*'
169 '[\t\s]*\([\t\s]*'+PCD_PATTERN
+'[\t\s]+GE[\t\s]+\d+[\t\s]*\)[\t\s]+AND[\t\s]+\([\t\s]*'+\
170 PCD_PATTERN
+'[\t\s]+LE[\t\s]+\d+[\t\s]*\)'
171 IntPattern1
= IntPattern1
.replace(' ', '')
172 IntPattern2
= '[\t\s]*'+PCD_PATTERN
+'[\t\s]+(LT|GT|LE|GE|XOR|EQ)[\t\s]+\d+[\t\s]*'
175 '[\t\s]*\([\t\s]*'+PCD_PATTERN
+'[\t\s]+GE[\t\s]+0[xX][0-9a-fA-F]+[\t\s]*\)[\t\s]+AND[\t\s]+\([\t\s]*'+\
176 PCD_PATTERN
+'[\t\s]+LE[\t\s]+0[xX][0-9a-fA-F]+[\t\s]*\)'
177 HexPattern1
= HexPattern1
.replace(' ', '')
178 HexPattern2
= '[\t\s]*'+PCD_PATTERN
+'[\t\s]+(LT|GT|LE|GE|XOR|EQ)[\t\s]+0[xX][0-9a-zA-Z]+[\t\s]*'
181 # Do the Hex1 conversion
183 HexMatchedList
= re
.compile(HexPattern1
).findall(ValidRangeExpr
)
185 for HexMatchedItem
in HexMatchedList
:
187 # To match items on both sides of '-'
189 RangeItemList
= re
.compile('[\t\s]*0[xX][0-9a-fA-F]+[\t\s]*').findall(HexMatchedItem
)
190 if RangeItemList
and len(RangeItemList
) == 2:
191 HexRangeDict
[HexMatchedItem
] = RangeItemList
193 for Key
in HexRangeDict
.keys():
194 MaxItem
= MixItem
= ''
195 if int(HexRangeDict
[Key
][0], 16) > int(HexRangeDict
[Key
][1], 16):
196 MaxItem
= HexRangeDict
[Key
][0]
197 MixItem
= HexRangeDict
[Key
][1]
199 MaxItem
= HexRangeDict
[Key
][1]
200 MixItem
= HexRangeDict
[Key
][0]
202 Range
= ' %s - %s' % (MixItem
.strip(), MaxItem
.strip())
203 ValidRangeExpr
= ValidRangeExpr
.replace(Key
, Range
)
205 # Do the INT1 conversion
208 IntMatchList
= re
.compile(IntPattern1
).findall(ValidRangeExpr
)
209 for MatchedItem
in IntMatchList
:
211 # To match items on both sides of '-'
213 RangeItemList
= re
.compile('[\t\s]*\d+[\t\s]*').findall(MatchedItem
)
214 if RangeItemList
and len(RangeItemList
) == 2:
215 IntRangeDict
[MatchedItem
] = RangeItemList
217 for Key
in IntRangeDict
.keys():
218 MaxItem
= MixItem
= ''
219 if int(IntRangeDict
[Key
][0]) > int(IntRangeDict
[Key
][1]):
220 MaxItem
= IntRangeDict
[Key
][0]
221 MixItem
= IntRangeDict
[Key
][1]
223 MaxItem
= IntRangeDict
[Key
][1]
224 MixItem
= IntRangeDict
[Key
][0]
226 Range
= ' %s - %s' % (MixItem
.strip(), MaxItem
.strip())
227 ValidRangeExpr
= ValidRangeExpr
.replace(Key
, Range
)
229 # Do the HEX2 conversion
231 for MatchObj
in re
.compile(HexPattern2
).finditer(ValidRangeExpr
):
232 MatchStr
= MatchObj
.group()
233 Range
= re
.compile(PCD_PATTERN
).sub(' ', MatchStr
)
234 ValidRangeExpr
= ValidRangeExpr
.replace(MatchStr
, Range
)
236 # Do the INT2 conversion
238 for MatchObj
in re
.compile(IntPattern2
).finditer(ValidRangeExpr
):
239 MatchStr
= MatchObj
.group()
240 Range
= re
.compile(PCD_PATTERN
).sub(' ', MatchStr
)
241 ValidRangeExpr
= ValidRangeExpr
.replace(MatchStr
, Range
)
243 return ValidRangeExpr
248 return "ValidValueList = %s ValidValueListLang = %s ValidValueRange \
249 = %s Expression = %s ErrorNumber = %s %s" % \
250 (self
.ValidValueList
, self
.ValidValueListLang
, self
.ValidValueRange
, \
251 self
.Expression
, self
.ErrorNumber
, self
.ErrorMessage
)
256 class PcdEntryXml(object):
258 self
.PcdItemType
= ''
260 self
.TokenSpaceGuidCName
= ''
261 self
.TokenSpaceGuidValue
= ''
267 self
.DefaultValue
= ''
268 self
.MaxDatumSize
= ''
271 self
.CommonDefines
= CommonDefinesXml()
277 # AsBuilt will use FromXml
279 def FromXml(self
, Item
, Key
):
281 XmlAttribute(XmlNode(Item
, '%s' % Key
), 'PcdItemType')
282 self
.PcdUsage
= XmlAttribute(XmlNode(Item
, '%s' % Key
), 'PcdUsage')
283 self
.TokenSpaceGuidCName
= \
284 XmlElement(Item
, '%s/TokenSpaceGuidCname' % Key
)
285 self
.TokenSpaceGuidValue
= \
286 XmlElement(Item
, '%s/TokenSpaceGuidValue' % Key
)
287 self
.Token
= XmlElement(Item
, '%s/Token' % Key
)
288 self
.CName
= XmlElement(Item
, '%s/CName' % Key
)
289 self
.PcdCName
= XmlElement(Item
, '%s/PcdCName' % Key
)
290 self
.DatumType
= XmlElement(Item
, '%s/DatumType' % Key
)
291 self
.ValidUsage
= XmlElement(Item
, '%s/ValidUsage' % Key
)
292 if not GlobalData
.gIS_BINARY_INF
:
293 self
.DefaultValue
= XmlElement(Item
, '%s/DefaultValue' % Key
)
295 self
.DefaultValue
= XmlElement(Item
, '%s/Value' % Key
)
296 self
.MaxDatumSize
= XmlElement(Item
, '%s/MaxDatumSize' % Key
)
297 self
.Value
= XmlElement(Item
, '%s/Value' % Key
)
298 self
.Offset
= XmlElement(Item
, '%s/Offset' % Key
)
299 self
.CommonDefines
.FromXml(XmlNode(Item
, '%s' % Key
), Key
)
301 for HelpTextItem
in XmlList(Item
, '%s/HelpText' % Key
):
302 HelpTextObj
= HelpTextXml()
303 HelpTextObj
.FromXml(HelpTextItem
, '%s/HelpText' % Key
)
304 self
.HelpText
.append(HelpTextObj
)
305 for PcdErrorItem
in XmlList(Item
, '%s/PcdError' % Key
):
306 PcdErrorObjXml
= PcdErrorXml()
307 PcdErrorObj
= PcdErrorObjXml
.FromXml(PcdErrorItem
, 'PcdError')
308 self
.PcdError
.append(PcdErrorObj
)
310 self
.DefaultValue
= ConvertNOTEQToNE(self
.DefaultValue
)
312 PcdEntry
= PcdObject()
313 PcdEntry
.SetSupArchList(self
.CommonDefines
.SupArchList
)
314 PcdEntry
.SetTokenSpaceGuidCName(self
.TokenSpaceGuidCName
)
315 PcdEntry
.SetTokenSpaceGuidValue(self
.TokenSpaceGuidValue
)
316 PcdEntry
.SetToken(self
.Token
)
317 PcdEntry
.SetOffset(self
.Offset
)
318 PcdEntry
.SetCName(self
.CName
)
319 PcdEntry
.SetPcdCName(self
.PcdCName
)
320 PcdEntry
.SetDatumType(self
.DatumType
)
321 PcdEntry
.SetValidUsage(self
.ValidUsage
)
322 PcdEntry
.SetDefaultValue(self
.DefaultValue
)
323 PcdEntry
.SetMaxDatumSize(self
.MaxDatumSize
)
324 PcdEntry
.SetFeatureFlag(ConvertNOTEQToNE(self
.CommonDefines
.FeatureFlag
))
325 PcdEntry
.SetItemType(self
.PcdItemType
)
327 PcdEntry
.SetHelpTextList(GetHelpTextList(self
.HelpText
))
328 PcdEntry
.SetPcdErrorsList(self
.PcdError
)
332 # Package will use FromXml2
334 def FromXml2(self
, Item
, Key
):
335 self
.TokenSpaceGuidCName
= \
336 XmlElement(Item
, '%s/TokenSpaceGuidCname' % Key
)
337 self
.Token
= XmlElement(Item
, '%s/Token' % Key
)
338 self
.CName
= XmlElement(Item
, '%s/CName' % Key
)
339 self
.DatumType
= XmlElement(Item
, '%s/DatumType' % Key
)
340 self
.ValidUsage
= XmlElement(Item
, '%s/ValidUsage' % Key
)
341 self
.DefaultValue
= XmlElement(Item
, '%s/DefaultValue' % Key
)
342 self
.MaxDatumSize
= XmlElement(Item
, '%s/MaxDatumSize' % Key
)
343 self
.CommonDefines
.FromXml(XmlNode(Item
, '%s' % Key
), Key
)
344 for PromptItem
in XmlList(Item
, '%s/Prompt' % Key
):
345 PromptObj
= PromptXml()
346 PromptObj
.FromXml(PromptItem
, '%s/Prompt' % Key
)
347 self
.Prompt
.append(PromptObj
)
348 for HelpTextItem
in XmlList(Item
, '%s/HelpText' % Key
):
349 HelpTextObj
= HelpTextXml()
350 HelpTextObj
.FromXml(HelpTextItem
, '%s/HelpText' % Key
)
351 self
.HelpText
.append(HelpTextObj
)
352 for PcdErrorItem
in XmlList(Item
, '%s/PcdError' % Key
):
353 PcdErrorObjXml
= PcdErrorXml()
354 PcdErrorObj
= PcdErrorObjXml
.FromXml(PcdErrorItem
, 'PcdError')
355 self
.PcdError
.append(PcdErrorObj
)
357 self
.DefaultValue
= ConvertNOTEQToNE(self
.DefaultValue
)
359 PcdEntry
= PcdObject()
360 PcdEntry
.SetSupArchList(self
.CommonDefines
.SupArchList
)
361 PcdEntry
.SetSupModuleList(self
.CommonDefines
.SupModList
)
362 PcdEntry
.SetTokenSpaceGuidCName(self
.TokenSpaceGuidCName
)
363 PcdEntry
.SetToken(self
.Token
)
364 PcdEntry
.SetCName(self
.CName
)
365 PcdEntry
.SetDatumType(self
.DatumType
)
366 PcdEntry
.SetValidUsage(self
.ValidUsage
)
367 PcdEntry
.SetDefaultValue(self
.DefaultValue
)
368 PcdEntry
.SetMaxDatumSize(self
.MaxDatumSize
)
369 PcdEntry
.SetFeatureFlag(ConvertNOTEQToNE(self
.CommonDefines
.FeatureFlag
))
371 PcdEntry
.SetPromptList(GetPromptList(self
.Prompt
))
372 PcdEntry
.SetHelpTextList(GetHelpTextList(self
.HelpText
))
373 PcdEntry
.SetPcdErrorsList(self
.PcdError
)
378 # Module will use FromXml3
380 def FromXml3(self
, Item
, Key
):
382 XmlAttribute(XmlNode(Item
, '%s' % Key
), 'PcdItemType')
383 self
.PcdUsage
= XmlAttribute(XmlNode(Item
, '%s' % Key
), 'PcdUsage')
384 self
.TokenSpaceGuidCName
= \
385 XmlElement(Item
, '%s/TokenSpaceGuidCName' % Key
)
386 self
.CName
= XmlElement(Item
, '%s/CName' % Key
)
387 self
.DefaultValue
= XmlElement(Item
, '%s/DefaultValue' % Key
)
388 self
.CommonDefines
.FromXml(XmlNode(Item
, '%s' % Key
), Key
)
389 for HelpTextItem
in XmlList(Item
, '%s/HelpText' % Key
):
390 HelpTextObj
= HelpTextXml()
391 HelpTextObj
.FromXml(HelpTextItem
, '%s/HelpText' % Key
)
392 self
.HelpText
.append(HelpTextObj
)
393 for PcdErrorItem
in XmlList(Item
, '%s/PcdError' % Key
):
394 PcdErrorObj
= PcdErrorXml()
395 PcdErrorObj
.FromXml(PcdErrorItem
, 'PcdError')
396 self
.PcdError
.append(PcdErrorObj
)
398 self
.DefaultValue
= ConvertNOTEQToNE(self
.DefaultValue
)
400 PcdEntry
= PcdObject()
401 PcdEntry
.SetSupArchList(self
.CommonDefines
.SupArchList
)
402 PcdEntry
.SetTokenSpaceGuidCName(self
.TokenSpaceGuidCName
)
403 PcdEntry
.SetCName(self
.CName
)
404 PcdEntry
.SetValidUsage(self
.PcdUsage
)
405 PcdEntry
.SetDefaultValue(self
.DefaultValue
)
406 PcdEntry
.SetFeatureFlag(ConvertNOTEQToNE(self
.CommonDefines
.FeatureFlag
))
407 PcdEntry
.SetItemType(self
.PcdItemType
)
409 PcdEntry
.SetHelpTextList(GetHelpTextList(self
.HelpText
))
410 PcdEntry
.SetPcdErrorsList(self
.PcdError
)
414 def ToXml(self
, PcdEntry
, Key
):
418 DefaultValue
= ConvertNEToNOTEQ(PcdEntry
.GetDefaultValue())
421 [['SupArchList', GetStringOfList(PcdEntry
.GetSupArchList())], \
422 ['PcdUsage', PcdEntry
.GetValidUsage()], \
423 ['PcdItemType', PcdEntry
.GetItemType()], \
424 ['FeatureFlag', PcdEntry
.GetFeatureFlag()],
426 NodeList
= [['TokenSpaceGuidCname', PcdEntry
.GetTokenSpaceGuidCName()],
427 ['TokenSpaceGuidValue', PcdEntry
.GetTokenSpaceGuidValue()],
428 ['Token', PcdEntry
.GetToken()],
429 ['CName', PcdEntry
.GetCName()],
430 ['DatumType', PcdEntry
.GetDatumType()],
431 ['ValidUsage', GetStringOfList(PcdEntry
.GetValidUsage())],
432 ['DefaultValue', DefaultValue
],
433 ['MaxDatumSize', PcdEntry
.GetMaxDatumSize()],
434 ['Offset', PcdEntry
.GetOffset()],
437 for Item
in PcdEntry
.GetHelpTextList():
439 NodeList
.append(Tmp
.ToXml(Item
))
440 for Item
in PcdEntry
.GetPcdErrorsList():
442 NodeList
.append(Tmp
.ToXml(Item
, 'PcdError'))
444 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, AttributeList
)
448 # Package will use ToXml2
450 def ToXml2(self
, PcdEntry
, Key
):
454 DefaultValue
= ConvertNEToNOTEQ(PcdEntry
.GetDefaultValue())
457 [['SupArchList', GetStringOfList(PcdEntry
.GetSupArchList())], \
458 ['SupModList', GetStringOfList(PcdEntry
.GetSupModuleList())]
460 NodeList
= [['TokenSpaceGuidCname', PcdEntry
.GetTokenSpaceGuidCName()],
461 ['Token', PcdEntry
.GetToken()],
462 ['CName', PcdEntry
.GetCName()],
463 ['DatumType', PcdEntry
.GetDatumType()],
464 ['ValidUsage', GetStringOfList(PcdEntry
.GetValidUsage())],
465 ['DefaultValue', DefaultValue
],
466 ['MaxDatumSize', PcdEntry
.GetMaxDatumSize()],
468 for Item
in PcdEntry
.GetPromptList():
470 NodeList
.append(Tmp
.ToXml(Item
))
472 for Item
in PcdEntry
.GetHelpTextList():
474 NodeList
.append(Tmp
.ToXml(Item
))
476 for Item
in PcdEntry
.GetPcdErrorsList():
478 NodeList
.append(Tmp
.ToXml(Item
, 'PcdError'))
480 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, AttributeList
)
484 # Module will use ToXml3
486 def ToXml3(self
, PcdEntry
, Key
):
490 DefaultValue
= ConvertNEToNOTEQ(PcdEntry
.GetDefaultValue())
493 [['SupArchList', GetStringOfList(PcdEntry
.GetSupArchList())], \
494 ['PcdUsage', PcdEntry
.GetValidUsage()], \
495 ['PcdItemType', PcdEntry
.GetItemType()], \
496 ['FeatureFlag', ConvertNEToNOTEQ(PcdEntry
.GetFeatureFlag())],
498 NodeList
= [['CName', PcdEntry
.GetCName()],
499 ['TokenSpaceGuidCName', PcdEntry
.GetTokenSpaceGuidCName()],
500 ['DefaultValue', DefaultValue
],
503 for Item
in PcdEntry
.GetHelpTextList():
505 NodeList
.append(Tmp
.ToXml(Item
))
506 for Item
in PcdEntry
.GetPcdErrorsList():
508 NodeList
.append(Tmp
.ToXml(Item
, 'PcdError'))
510 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, AttributeList
)
515 # AsBuild Module will use ToXml4
517 def ToXml4(self
, PcdEntry
, Key
):
521 DefaultValue
= ConvertNEToNOTEQ(PcdEntry
.GetDefaultValue())
526 ['TokenSpaceGuidValue', PcdEntry
.GetTokenSpaceGuidValue()],
527 ['PcdCName', PcdEntry
.GetCName()],
528 ['Token', PcdEntry
.GetToken()],
529 ['DatumType', PcdEntry
.GetDatumType()],
530 ['MaxDatumSize', PcdEntry
.GetMaxDatumSize()],
531 ['Value', DefaultValue
],
532 ['Offset', PcdEntry
.GetOffset()]
535 for Item
in PcdEntry
.GetHelpTextList():
537 NodeList
.append(Tmp
.ToXml(Item
))
538 for Item
in PcdEntry
.GetPcdErrorsList():
540 NodeList
.append(Tmp
.ToXml(Item
, 'PcdError'))
542 Root
= CreateXmlElement('%s' % Key
, '', NodeList
, AttributeList
)
549 ('PcdItemType = %s PcdUsage = %s TokenSpaceGuidCName = %s \
550 TokenSpaceGuidValue = %s Token = %s CName = %s PcdCName = %s \
551 DatumType = %s ValidUsage = %s DefaultValue = %s MaxDatumSize = %s \
552 Value = %s Offset = %s %s') % \
553 (self
.PcdItemType
, self
.PcdUsage
, self
.TokenSpaceGuidCName
, \
554 self
.TokenSpaceGuidValue
, self
.Token
, self
.CName
, self
.PcdCName
, \
555 self
.DatumType
, self
.ValidUsage
, self
.DefaultValue
, \
556 self
.MaxDatumSize
, self
.Value
, self
.Offset
, self
.CommonDefines
)
557 for Item
in self
.HelpText
:
558 Str
= Str
+ "\n\t" + str(Item
)
559 for Item
in self
.PcdError
:
560 Str
= Str
+ "\n\tPcdError:" + str(Item
)