1 # Copyright (c) 2015, Intel Corporation. All rights reserved.<BR>
2 # This program and the accompanying materials
3 # are licensed and made available under the terms and conditions of the BSD License
4 # which accompanies this distribution. The full text of the license may be found at
5 # http://opensource.org/licenses/bsd-license.php
7 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
8 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
11 # This file is used to collect the Variable checking information
18 from Common
.RangeExpression
import RangeExpression
19 from Common
.Misc
import *
20 from StringIO
import StringIO
21 from struct
import pack
23 class VAR_CHECK_PCD_VARIABLE_TAB_CONTAINER(object):
25 self
.var_check_info
= []
27 def push_back(self
, var_check_tab
):
28 for tab
in self
.var_check_info
:
29 if tab
.equal(var_check_tab
):
30 tab
.merge(var_check_tab
)
33 self
.var_check_info
.append(var_check_tab
)
35 def dump(self
, dest
, Phase
):
43 if not os
.path
.isabs(dest
):
45 if not os
.path
.exists(dest
):
47 BinFileName
= "PcdVarCheck.bin"
48 BinFilePath
= os
.path
.join(dest
, BinFileName
)
51 for var_check_tab
in self
.var_check_info
:
55 Name
= var_check_tab
.Name
[1:-1]
56 NameChars
= Name
.split(",")
57 realLength
+= len(NameChars
)
58 if (index
< len(self
.var_check_info
) and realLength
% 4) or (index
== len(self
.var_check_info
) and len(var_check_tab
.validtab
) > 0 and realLength
% 4):
59 realLength
+= (4 - (realLength
% 4))
61 for item
in var_check_tab
.validtab
:
64 for v_data
in item
.data
:
65 if type(v_data
) in (int, long):
66 realLength
+= item
.StorageWidth
68 realLength
+= item
.StorageWidth
69 realLength
+= item
.StorageWidth
70 if (index
== len(self
.var_check_info
)) :
71 if (itemIndex
< len(var_check_tab
.validtab
)) and realLength
% 4:
72 realLength
+= (4 - (realLength
% 4))
75 realLength
+= (4 - (realLength
% 4))
76 var_check_tab
.Length
= realLength
79 for var_check_tab
in self
.var_check_info
:
82 b
= pack("=H", var_check_tab
.Revision
)
86 b
= pack("=H", var_check_tab
.HeaderLength
)
90 b
= pack("=L", var_check_tab
.Length
)
94 b
= pack("=B", var_check_tab
.Type
)
99 b
= pack("=B", var_check_tab
.Reserved
)
103 b
= pack("=L", var_check_tab
.Attributes
)
107 Guid
= var_check_tab
.Guid
108 b
= pack('=LHHBBBBBBBB',
124 Name
= var_check_tab
.Name
[1:-1]
125 NameChars
= Name
.split(",")
126 for NameChar
in NameChars
:
127 NameCharNum
= int(NameChar
, 16)
128 b
= pack("=B", NameCharNum
)
132 if (index
< len(self
.var_check_info
) and realLength
% 4) or (index
== len(self
.var_check_info
) and len(var_check_tab
.validtab
) > 0 and realLength
% 4):
133 for i
in range(4 - (realLength
% 4)):
134 b
= pack("=B", var_check_tab
.pad
)
138 for item
in var_check_tab
.validtab
:
141 b
= pack("=B", item
.Type
)
145 b
= pack("=B", item
.Length
)
149 b
= pack("=H", int(item
.VarOffset
, 16))
153 b
= pack("=B", item
.StorageWidth
)
156 for v_data
in item
.data
:
157 if type(v_data
) in (int, long):
158 b
= pack(FormatMap
[item
.StorageWidth
], v_data
)
160 realLength
+= item
.StorageWidth
162 b
= pack(FormatMap
[item
.StorageWidth
], v_data
[0])
164 realLength
+= item
.StorageWidth
165 b
= pack(FormatMap
[item
.StorageWidth
], v_data
[1])
167 realLength
+= item
.StorageWidth
169 if (index
== len(self
.var_check_info
)) :
170 if (itemIndex
< len(var_check_tab
.validtab
)) and realLength
% 4:
171 for i
in range(4 - (realLength
% 4)):
172 b
= pack("=B", var_check_tab
.pad
)
177 for i
in range(4 - (realLength
% 4)):
178 b
= pack("=B", var_check_tab
.pad
)
183 if Phase
== 'DXE' and os
.path
.exists(BinFilePath
):
184 BinFile
= open(BinFilePath
, "rb")
185 BinBuffer
= BinFile
.read()
187 BinBufferSize
= len(BinBuffer
)
188 if (BinBufferSize
% 4):
189 for i
in range(4 - (BinBufferSize
% 4)):
190 b
= pack("=B", VAR_CHECK_PCD_VARIABLE_TAB
.pad
)
192 Buffer
= BinBuffer
+ Buffer
194 SaveFileOnChange(BinFilePath
, DbFile
.getvalue(), True)
197 class VAR_CHECK_PCD_VARIABLE_TAB(object):
199 def __init__(self
, TokenSpaceGuid
, PcdCName
):
200 self
.Revision
= 0x0001
201 self
.HeaderLength
= 0
202 self
.Length
= 0 # Length include this header
205 self
.Attributes
= 0x00000000
206 self
.Guid
= eval("[" + TokenSpaceGuid
.replace("{", "").replace("}", "") + "]")
210 def UpdateSize(self
):
211 self
.HeaderLength
= 32 + len(self
.Name
.split(","))
212 self
.Length
= 32 + len(self
.Name
.split(",")) + self
.GetValidTabLen()
214 def GetValidTabLen(self
):
216 for item
in self
.validtab
:
217 validtablen
+= item
.Length
220 def SetAttributes(self
, attributes
):
221 self
.Attributes
= attributes
223 def push_back(self
, valid_obj
):
224 if valid_obj
is not None:
225 self
.validtab
.append(valid_obj
)
227 def equal(self
, varchecktab
):
228 if self
.Guid
== varchecktab
.Guid
and self
.Name
== varchecktab
.Name
:
233 def merge(self
, varchecktab
):
234 for validobj
in varchecktab
.validtab
:
235 if validobj
in self
.validtab
:
237 self
.validtab
.append(validobj
)
241 class VAR_CHECK_PCD_VALID_OBJ(object):
242 def __init__(self
, VarOffset
, data
, PcdDataType
):
244 self
.Length
= 0 # Length include this header
245 self
.VarOffset
= VarOffset
246 self
.StorageWidth
= 0
247 self
.PcdDataType
= PcdDataType
.strip()
250 self
.ValidData
= True
251 self
.updateStorageWidth()
252 def updateStorageWidth(self
):
253 if self
.PcdDataType
== "UINT8" or self
.PcdDataType
== "BOOLEAN":
254 self
.StorageWidth
= 1
255 elif self
.PcdDataType
== "UINT16":
256 self
.StorageWidth
= 2
257 elif self
.PcdDataType
== "UINT32":
258 self
.StorageWidth
= 4
259 elif self
.PcdDataType
== "UINT64":
260 self
.StorageWidth
= 8
262 self
.StorageWidth
= 0
263 self
.ValidData
= False
265 def __eq__(self
, validObj
):
266 if self
.VarOffset
== validObj
.VarOffset
:
271 class VAR_CHECK_PCD_VALID_LIST(VAR_CHECK_PCD_VALID_OBJ
):
272 def __init__(self
, VarOffset
, validlist
, PcdDataType
):
273 super(VAR_CHECK_PCD_VALID_LIST
, self
).__init
__(VarOffset
, validlist
, PcdDataType
)
277 def update_data(self
):
280 for item
in self
.rawdata
:
281 valid_num_list
.extend(item
.split(','))
283 for valid_num
in valid_num_list
:
284 valid_num
= valid_num
.strip()
286 if valid_num
.startswith('0x') or valid_num
.startswith('0X'):
287 data_list
.append(int(valid_num
, 16))
289 data_list
.append(int(valid_num
))
292 self
.data
= set(data_list
)
294 def update_size(self
):
295 self
.Length
= 5 + len(self
.data
) * self
.StorageWidth
298 class VAR_CHECK_PCD_VALID_RANGE(VAR_CHECK_PCD_VALID_OBJ
):
299 def __init__(self
, VarOffset
, validrange
, PcdDataType
):
300 super(VAR_CHECK_PCD_VALID_RANGE
, self
).__init
__(VarOffset
, validrange
, PcdDataType
)
304 def update_data(self
):
308 for item
in self
.rawdata
:
310 RangeExpr
= "( " + item
+ " )"
312 RangeExpr
= RangeExpr
+ "OR ( " + item
+ " )"
313 range_result
= RangeExpression(RangeExpr
, self
.PcdDataType
)(True)
314 for rangelist
in range_result
:
315 for obj
in rangelist
.pop():
316 data_list
.append((obj
.start
, obj
.end
))
317 self
.data
= set(data_list
)
319 def update_size(self
):
320 self
.Length
= 5 + len(self
.data
) * 2 * self
.StorageWidth
323 class VAR_VALID_OBJECT_FACTORY(object):
327 def Get_valid_object(PcdClass
, VarOffset
):
328 if PcdClass
.validateranges
:
329 return VAR_CHECK_PCD_VALID_RANGE(VarOffset
, PcdClass
.validateranges
, PcdClass
.DatumType
)
330 if PcdClass
.validlists
:
331 return VAR_CHECK_PCD_VALID_LIST(VarOffset
, PcdClass
.validlists
, PcdClass
.DatumType
)
335 if __name__
== "__main__":
336 class TestObj(object):
337 def __init__(self
, number1
):
338 self
.number_1
= number1
339 def __eq__(self
, testobj
):
340 if self
.number_1
== testobj
.number_1
:
347 testarr
= [test1
, test2
]
348 print TestObj(2) in testarr
349 print TestObj(2) == test2