BaseTools/Source/Python/AutoGen/ValidCheckingInfoObject.py

   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
   6 #
   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.
   9
  10 #
  11 # This file is used to collect the Variable checking information
  12 #
  13
  14 # #
  15 # Import Modules
  16 #
  17 import os
  18 from Common.RangeExpression import RangeExpression
  19 from Common.Misc import *
  20 from StringIO import StringIO
  21 from struct import pack
  22
  23 class VAR_CHECK_PCD_VARIABLE_TAB_CONTAINER(object):
  24     def __init__(self):
  25         self.var_check_info = []
  26
  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)
  31                 break
  32         else:
  33             self.var_check_info.append(var_check_tab)
  34
  35     def dump(self, dest, Phase):
  36
  37         FormatMap = {}
  38         FormatMap[1] = "=B"
  39         FormatMap[2] = "=H"
  40         FormatMap[4] = "=L"
  41         FormatMap[8] = "=Q"
  42
  43         if not os.path.isabs(dest):
  44             return
  45         if not os.path.exists(dest):
  46             os.mkdir(dest)
  47         BinFileName = "PcdVarCheck.bin"
  48         BinFilePath = os.path.join(dest, BinFileName)
  49         Buffer = ''
  50         index = 0
  51         for var_check_tab in self.var_check_info:
  52             index += 1
  53             realLength = 0
  54             realLength += 32
  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))
  60             itemIndex = 0
  61             for item in var_check_tab.validtab:
  62                 itemIndex += 1
  63                 realLength += 5
  64                 for v_data in item.data:
  65                     if type(v_data) == type(1):
  66                         realLength += item.StorageWidth
  67                     else:
  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))
  73                 else:
  74                     if realLength % 4:
  75                         realLength += (4 - (realLength % 4))
  76             var_check_tab.Length = realLength
  77         realLength = 0
  78         index = 0
  79         for var_check_tab in self.var_check_info:
  80             index += 1
  81
  82             b = pack("=H", var_check_tab.Revision)
  83             Buffer += b
  84             realLength += 2
  85
  86             b = pack("=H", var_check_tab.HeaderLength)
  87             Buffer += b
  88             realLength += 2
  89
  90             b = pack("=L", var_check_tab.Length)
  91             Buffer += b
  92             realLength += 4
  93
  94             b = pack("=B", var_check_tab.Type)
  95             Buffer += b
  96             realLength += 1
  97
  98             for i in range(0, 3):
  99                 b = pack("=B", var_check_tab.Reserved)
 100                 Buffer += b
 101                 realLength += 1
 102
 103             b = pack("=L", var_check_tab.Attributes)
 104             Buffer += b
 105             realLength += 4
 106
 107             Guid = var_check_tab.Guid
 108             b = pack('=LHHBBBBBBBB',
 109                 Guid[0],
 110                 Guid[1],
 111                 Guid[2],
 112                 Guid[3],
 113                 Guid[4],
 114                 Guid[5],
 115                 Guid[6],
 116                 Guid[7],
 117                 Guid[8],
 118                 Guid[9],
 119                 Guid[10],
 120                 )
 121             Buffer += b
 122             realLength += 16
 123
 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)
 129                 Buffer += b
 130                 realLength += 1
 131
 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)
 135                     Buffer += b
 136                     realLength += 1
 137             itemIndex = 0
 138             for item in var_check_tab.validtab:
 139                 itemIndex += 1
 140
 141                 b = pack("=B", item.Type)
 142                 Buffer += b
 143                 realLength += 1
 144
 145                 b = pack("=B", item.Length)
 146                 Buffer += b
 147                 realLength += 1
 148
 149                 b = pack("=H", int(item.VarOffset, 16))
 150                 Buffer += b
 151                 realLength += 2
 152
 153                 b = pack("=B", item.StorageWidth)
 154                 Buffer += b
 155                 realLength += 1
 156
 157                 for v_data in item.data:
 158                     if type(v_data) == type(1):
 159                         b = pack(FormatMap[item.StorageWidth], v_data)
 160                         Buffer += b
 161                         realLength += item.StorageWidth
 162                     else:
 163                         b = pack(FormatMap[item.StorageWidth], v_data[0])
 164                         Buffer += b
 165                         realLength += item.StorageWidth
 166                         b = pack(FormatMap[item.StorageWidth], v_data[1])
 167                         Buffer += b
 168                         realLength += item.StorageWidth
 169
 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)
 174                             Buffer += b
 175                             realLength += 1
 176                 else:
 177                     if realLength % 4:
 178                         for i in range(4 - (realLength % 4)):
 179                             b = pack("=B", var_check_tab.pad)
 180                             Buffer += b
 181                             realLength += 1
 182
 183         DbFile = StringIO()
 184         if Phase == 'DXE' and os.path.exists(BinFilePath):
 185             BinFile = open(BinFilePath, "rb")
 186             BinBuffer = BinFile.read()
 187             BinFile.close()
 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)
 192                     BinBuffer += b
 193             Buffer = BinBuffer + Buffer
 194         DbFile.write(Buffer)
 195         SaveFileOnChange(BinFilePath, DbFile.getvalue(), True)
 196
 197
 198 class VAR_CHECK_PCD_VARIABLE_TAB(object):
 199     pad = 0xDA
 200     def __init__(self, TokenSpaceGuid, PcdCName):
 201         self.Revision = 0x0001
 202         self.HeaderLength = 0
 203         self.Length = 0  # Length include this header
 204         self.Type = 0
 205         self.Reserved = 0
 206         self.Attributes = 0x00000000
 207         self.Guid = eval("[" + TokenSpaceGuid.replace("{", "").replace("}", "") + "]")
 208         self.Name = PcdCName
 209         self.validtab = []
 210
 211     def UpdateSize(self):
 212         self.HeaderLength = 32 + len(self.Name.split(","))
 213         self.Length = 32 + len(self.Name.split(",")) + self.GetValidTabLen()
 214
 215     def GetValidTabLen(self):
 216         validtablen = 0
 217         for item in self.validtab:
 218             validtablen += item.Length
 219         return validtablen
 220
 221     def SetAttributes(self, attributes):
 222         self.Attributes = attributes
 223
 224     def push_back(self, valid_obj):
 225         if valid_obj is not None:
 226             self.validtab.append(valid_obj)
 227
 228     def equal(self, varchecktab):
 229         if self.Guid == varchecktab.Guid and self.Name == varchecktab.Name:
 230             return True
 231         else:
 232             return False
 233
 234     def merge(self, varchecktab):
 235         for validobj in varchecktab.validtab:
 236             if validobj in self.validtab:
 237                 continue
 238             self.validtab.append(validobj)
 239         self.UpdateSize()
 240
 241
 242 class VAR_CHECK_PCD_VALID_OBJ(object):
 243     def __init__(self, VarOffset, data, PcdDataType):
 244         self.Type = 1
 245         self.Length = 0  # Length include this header
 246         self.VarOffset = VarOffset
 247         self.StorageWidth = 0
 248         self.PcdDataType = PcdDataType.strip()
 249         self.rawdata = data
 250         self.data = set()
 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
 262         else:
 263             self.StorageWidth = 0
 264             self.ValidData = False
 265
 266     def __eq__(self, validObj):
 267         if self.VarOffset == validObj.VarOffset:
 268             return True
 269         else:
 270             return False
 271
 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)
 275         self.Type = 1
 276         self.update_data()
 277         self.update_size()
 278     def update_data(self):
 279         valid_num_list = []
 280         data_list = []
 281         for item in self.rawdata:
 282             valid_num_list.extend(item.split(','))
 283
 284         for valid_num in valid_num_list:
 285             valid_num = valid_num.strip()
 286
 287             if valid_num.startswith('0x') or valid_num.startswith('0X'):
 288                 data_list.append(int(valid_num, 16))
 289             else:
 290                 data_list.append(int(valid_num))
 291
 292
 293         self.data = set(data_list)
 294
 295     def update_size(self):
 296         self.Length = 5 + len(self.data) * self.StorageWidth
 297
 298
 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)
 302         self.Type = 2
 303         self.update_data()
 304         self.update_size()
 305     def update_data(self):
 306         RangeExpr = ""
 307         data_list = []
 308         i = 0
 309         for item in self.rawdata:
 310             if i == 0:
 311                 RangeExpr = "( " + item + " )"
 312             else:
 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)
 319
 320     def update_size(self):
 321         self.Length = 5 + len(self.data) * 2 * self.StorageWidth
 322
 323
 324 class VAR_VALID_OBJECT_FACTORY(object):
 325     def __init__(self):
 326         pass
 327     @staticmethod
 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)
 333         else:
 334             return None
 335
 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:
 342                 return True
 343             else:
 344                 return False
 345     test1 = TestObj(1)
 346     test2 = TestObj(2)
 347
 348     testarr = [test1, test2]
 349     print TestObj(2) in testarr
 350     print TestObj(2) == test2
 351