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
) == type(1):
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
)
157 for v_data
in item
.data
:
158 if type(v_data
) == type(1):
159 b
= pack(FormatMap
[item
.StorageWidth
], v_data
)
161 realLength
+= item
.StorageWidth
163 b
= pack(FormatMap
[item
.StorageWidth
], v_data
[0])
165 realLength
+= item
.StorageWidth
166 b
= pack(FormatMap
[item
.StorageWidth
], v_data
[1])
168 realLength
+= item
.StorageWidth
170 if (index
== len(self
.var_check_info
)) :
171 if (itemIndex
< len(var_check_tab
.validtab
)) and realLength
% 4:
172 for i
in range(4 - (realLength
% 4)):
173 b
= pack("=B", var_check_tab
.pad
)
178 for i
in range(4 - (realLength
% 4)):
179 b
= pack("=B", var_check_tab
.pad
)
184 if Phase
== 'DXE' and os
.path
.exists(BinFilePath
):
185 BinFile
= open(BinFilePath
, "rb")
186 BinBuffer
= BinFile
.read()
188 BinBufferSize
= len(BinBuffer
)
189 if (BinBufferSize
% 4):
190 for i
in range(4 - (BinBufferSize
% 4)):
191 b
= pack("=B", VAR_CHECK_PCD_VARIABLE_TAB
.pad
)
193 Buffer
= BinBuffer
+ Buffer
195 SaveFileOnChange(BinFilePath
, DbFile
.getvalue(), True)
198 class VAR_CHECK_PCD_VARIABLE_TAB(object):
200 def __init__(self
, TokenSpaceGuid
, PcdCName
):
201 self
.Revision
= 0x0001
202 self
.HeaderLength
= 0
203 self
.Length
= 0 # Length include this header
206 self
.Attributes
= 0x00000000
207 self
.Guid
= eval("[" + TokenSpaceGuid
.replace("{", "").replace("}", "") + "]")
211 def UpdateSize(self
):
212 self
.HeaderLength
= 32 + len(self
.Name
.split(","))
213 self
.Length
= 32 + len(self
.Name
.split(",")) + self
.GetValidTabLen()
215 def GetValidTabLen(self
):
217 for item
in self
.validtab
:
218 validtablen
+= item
.Length
221 def SetAttributes(self
, attributes
):
222 self
.Attributes
= attributes
224 def push_back(self
, valid_obj
):
225 if valid_obj
is not None:
226 self
.validtab
.append(valid_obj
)
228 def equal(self
, varchecktab
):
229 if self
.Guid
== varchecktab
.Guid
and self
.Name
== varchecktab
.Name
:
234 def merge(self
, varchecktab
):
235 for validobj
in varchecktab
.validtab
:
236 if validobj
in self
.validtab
:
238 self
.validtab
.append(validobj
)
242 class VAR_CHECK_PCD_VALID_OBJ(object):
243 def __init__(self
, VarOffset
, data
, PcdDataType
):
245 self
.Length
= 0 # Length include this header
246 self
.VarOffset
= VarOffset
247 self
.StorageWidth
= 0
248 self
.PcdDataType
= PcdDataType
.strip()
251 self
.ValidData
= True
252 self
.updateStorageWidth()
253 def updateStorageWidth(self
):
254 if self
.PcdDataType
== "UINT8" or self
.PcdDataType
== "BOOLEAN":
255 self
.StorageWidth
= 1
256 elif self
.PcdDataType
== "UINT16":
257 self
.StorageWidth
= 2
258 elif self
.PcdDataType
== "UINT32":
259 self
.StorageWidth
= 4
260 elif self
.PcdDataType
== "UINT64":
261 self
.StorageWidth
= 8
263 self
.StorageWidth
= 0
264 self
.ValidData
= False
266 def __eq__(self
, validObj
):
267 if self
.VarOffset
== validObj
.VarOffset
:
272 class VAR_CHECK_PCD_VALID_LIST(VAR_CHECK_PCD_VALID_OBJ
):
273 def __init__(self
, VarOffset
, validlist
, PcdDataType
):
274 super(VAR_CHECK_PCD_VALID_LIST
, self
).__init
__(VarOffset
, validlist
, PcdDataType
)
278 def update_data(self
):
281 for item
in self
.rawdata
:
282 valid_num_list
.extend(item
.split(','))
284 for valid_num
in valid_num_list
:
285 valid_num
= valid_num
.strip()
287 if valid_num
.startswith('0x') or valid_num
.startswith('0X'):
288 data_list
.append(int(valid_num
, 16))
290 data_list
.append(int(valid_num
))
293 self
.data
= set(data_list
)
295 def update_size(self
):
296 self
.Length
= 5 + len(self
.data
) * self
.StorageWidth
299 class VAR_CHECK_PCD_VALID_RANGE(VAR_CHECK_PCD_VALID_OBJ
):
300 def __init__(self
, VarOffset
, validrange
, PcdDataType
):
301 super(VAR_CHECK_PCD_VALID_RANGE
, self
).__init
__(VarOffset
, validrange
, PcdDataType
)
305 def update_data(self
):
309 for item
in self
.rawdata
:
311 RangeExpr
= "( " + item
+ " )"
313 RangeExpr
= RangeExpr
+ "OR ( " + item
+ " )"
314 range_result
= RangeExpression(RangeExpr
, self
.PcdDataType
)(True)
315 for rangelist
in range_result
:
316 for obj
in rangelist
.pop():
317 data_list
.append((obj
.start
, obj
.end
))
318 self
.data
= set(data_list
)
320 def update_size(self
):
321 self
.Length
= 5 + len(self
.data
) * 2 * self
.StorageWidth
324 class VAR_VALID_OBJECT_FACTORY(object):
328 def Get_valid_object(PcdClass
, VarOffset
):
329 if PcdClass
.validateranges
:
330 return VAR_CHECK_PCD_VALID_RANGE(VarOffset
, PcdClass
.validateranges
, PcdClass
.DatumType
)
331 if PcdClass
.validlists
:
332 return VAR_CHECK_PCD_VALID_LIST(VarOffset
, PcdClass
.validlists
, PcdClass
.DatumType
)
336 if __name__
== "__main__":
337 class TestObj(object):
338 def __init__(self
, number1
):
339 self
.number_1
= number1
340 def __eq__(self
, testobj
):
341 if self
.number_1
== testobj
.number_1
:
348 testarr
= [test1
, test2
]
349 print TestObj(2) in testarr
350 print TestObj(2) == test2