[mirror_edk2.git] / BaseTools / Source / Python / AutoGen / ValidCheckingInfoObject.py

# Copyright (c) 2015, Intel Corporation. All rights reserved.<BR>\r
# This program and the accompanying materials\r
# are licensed and made available under the terms and conditions of the BSD License\r
# which accompanies this distribution.  The full text of the license may be found at\r
# http://opensource.org/licenses/bsd-license.php\r
#\r
# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
#\r
# This file is used to collect the Variable checking information\r
#\r
\r
# #\r
# Import Modules\r
#\r
import os\r
from Common.RangeExpression import RangeExpression\r
from Common.Misc import *\r
from StringIO import StringIO\r
from struct import pack\r
\r
class VAR_CHECK_PCD_VARIABLE_TAB_CONTAINER(object):\r
    def __init__(self):\r
        self.var_check_info = []\r
        \r
    def push_back(self, var_check_tab):\r
        for tab in self.var_check_info:\r
            if tab.equal(var_check_tab):\r
                tab.merge(var_check_tab)\r
                break\r
        else:\r
            self.var_check_info.append(var_check_tab)\r
    \r
    def dump(self, dest, Phase):\r
        \r
        FormatMap = {}\r
        FormatMap[1] = "=B"\r
        FormatMap[2] = "=H"\r
        FormatMap[4] = "=L"\r
        FormatMap[8] = "=Q"\r
        \r
        if not os.path.isabs(dest):\r
            return\r
        if not os.path.exists(dest):\r
            os.mkdir(dest)\r
        BinFileName = "PcdVarCheck.bin"\r
        BinFilePath = os.path.join(dest, BinFileName)\r
        Buffer = ''\r
        index = 0\r
        for var_check_tab in self.var_check_info:\r
            index += 1\r
            realLength = 0\r
            realLength += 32\r
            Name = var_check_tab.Name[1:-1]\r
            NameChars = Name.split(",")\r
            realLength += len(NameChars)\r
            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):\r
                realLength += (4 - (realLength % 4))\r
            itemIndex = 0\r
            for item in var_check_tab.validtab:\r
                itemIndex += 1\r
                realLength += 5\r
                for v_data in item.data:\r
                    if type(v_data) in (int, long):\r
                        realLength += item.StorageWidth\r
                    else:\r
                        realLength += item.StorageWidth\r
                        realLength += item.StorageWidth\r
                if (index == len(self.var_check_info)) :\r
                    if (itemIndex < len(var_check_tab.validtab)) and realLength % 4:\r
                        realLength += (4 - (realLength % 4))\r
                else:\r
                    if realLength % 4:\r
                        realLength += (4 - (realLength % 4))\r
            var_check_tab.Length = realLength\r
        realLength = 0\r
        index = 0\r
        for var_check_tab in self.var_check_info:\r
            index += 1\r
\r
            b = pack("=H", var_check_tab.Revision)\r
            Buffer += b\r
            realLength += 2\r
\r
            b = pack("=H", var_check_tab.HeaderLength)\r
            Buffer += b\r
            realLength += 2\r
\r
            b = pack("=L", var_check_tab.Length)\r
            Buffer += b\r
            realLength += 4\r
\r
            b = pack("=B", var_check_tab.Type)\r
            Buffer += b\r
            realLength += 1\r
\r
            for i in range(0, 3):\r
                b = pack("=B", var_check_tab.Reserved)\r
                Buffer += b\r
                realLength += 1\r
\r
            b = pack("=L", var_check_tab.Attributes)\r
            Buffer += b\r
            realLength += 4\r
\r
            Guid = var_check_tab.Guid\r
            b = pack('=LHHBBBBBBBB',\r
                Guid[0],\r
                Guid[1],\r
                Guid[2],\r
                Guid[3],\r
                Guid[4],\r
                Guid[5],\r
                Guid[6],\r
                Guid[7],\r
                Guid[8],\r
                Guid[9],\r
                Guid[10],\r
                )\r
            Buffer += b\r
            realLength += 16\r
\r
            Name = var_check_tab.Name[1:-1]\r
            NameChars = Name.split(",")\r
            for NameChar in NameChars:\r
                NameCharNum = int(NameChar, 16)\r
                b = pack("=B", NameCharNum)\r
                Buffer += b\r
                realLength += 1\r
\r
            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):\r
                for i in range(4 - (realLength % 4)):\r
                    b = pack("=B", var_check_tab.pad)\r
                    Buffer += b\r
                    realLength += 1\r
            itemIndex = 0\r
            for item in var_check_tab.validtab:\r
                itemIndex += 1\r
\r
                b = pack("=B", item.Type)\r
                Buffer += b\r
                realLength += 1\r
\r
                b = pack("=B", item.Length)\r
                Buffer += b\r
                realLength += 1\r
\r
                b = pack("=H", int(item.VarOffset, 16))\r
                Buffer += b\r
                realLength += 2\r
\r
                b = pack("=B", item.StorageWidth)\r
                Buffer += b\r
                realLength += 1\r
                for v_data in item.data:\r
                    if type(v_data) in (int, long):\r
                        b = pack(FormatMap[item.StorageWidth], v_data)\r
                        Buffer += b\r
                        realLength += item.StorageWidth\r
                    else:\r
                        b = pack(FormatMap[item.StorageWidth], v_data[0])\r
                        Buffer += b\r
                        realLength += item.StorageWidth\r
                        b = pack(FormatMap[item.StorageWidth], v_data[1])\r
                        Buffer += b\r
                        realLength += item.StorageWidth\r
\r
                if (index == len(self.var_check_info)) :\r
                    if (itemIndex < len(var_check_tab.validtab)) and realLength % 4:\r
                        for i in range(4 - (realLength % 4)):\r
                            b = pack("=B", var_check_tab.pad)\r
                            Buffer += b\r
                            realLength += 1\r
                else:\r
                    if realLength % 4:\r
                        for i in range(4 - (realLength % 4)):\r
                            b = pack("=B", var_check_tab.pad)\r
                            Buffer += b\r
                            realLength += 1\r
        \r
        DbFile = StringIO()\r
        if Phase == 'DXE' and os.path.exists(BinFilePath):\r
            BinFile = open(BinFilePath, "rb")\r
            BinBuffer = BinFile.read()\r
            BinFile.close()\r
            BinBufferSize = len(BinBuffer)\r
            if (BinBufferSize % 4):\r
                for i in range(4 - (BinBufferSize % 4)):\r
                    b = pack("=B", VAR_CHECK_PCD_VARIABLE_TAB.pad)\r
                    BinBuffer += b\r
            Buffer = BinBuffer + Buffer\r
        DbFile.write(Buffer)\r
        SaveFileOnChange(BinFilePath, DbFile.getvalue(), True)\r
    \r
\r
class VAR_CHECK_PCD_VARIABLE_TAB(object):\r
    pad = 0xDA\r
    def __init__(self, TokenSpaceGuid, PcdCName):\r
        self.Revision = 0x0001\r
        self.HeaderLength = 0\r
        self.Length = 0  # Length include this header\r
        self.Type = 0\r
        self.Reserved = 0\r
        self.Attributes = 0x00000000\r
        self.Guid = eval("[" + TokenSpaceGuid.replace("{", "").replace("}", "") + "]")\r
        self.Name = PcdCName\r
        self.validtab = []\r
\r
    def UpdateSize(self):\r
        self.HeaderLength = 32 + len(self.Name.split(","))\r
        self.Length = 32 + len(self.Name.split(",")) + self.GetValidTabLen()\r
    \r
    def GetValidTabLen(self):\r
        validtablen = 0\r
        for item in self.validtab:\r
            validtablen += item.Length  \r
        return validtablen \r
    \r
    def SetAttributes(self, attributes):\r
        self.Attributes = attributes\r
            \r
    def push_back(self, valid_obj):\r
        if valid_obj is not None:\r
            self.validtab.append(valid_obj)\r
        \r
    def equal(self, varchecktab):\r
        if self.Guid == varchecktab.Guid and self.Name == varchecktab.Name:\r
            return True\r
        else:\r
            return False\r
        \r
    def merge(self, varchecktab):\r
        for validobj in varchecktab.validtab:\r
            if validobj in self.validtab:\r
                continue\r
            self.validtab.append(validobj)\r
        self.UpdateSize()\r
\r
\r
class VAR_CHECK_PCD_VALID_OBJ(object):\r
    def __init__(self, VarOffset, data, PcdDataType):\r
        self.Type = 1\r
        self.Length = 0  # Length include this header\r
        self.VarOffset = VarOffset\r
        self.StorageWidth = 0\r
        self.PcdDataType = PcdDataType.strip()\r
        self.rawdata = data\r
        self.data = set()\r
        self.ValidData = True\r
        self.updateStorageWidth()\r
    def updateStorageWidth(self):\r
        if self.PcdDataType == "UINT8" or self.PcdDataType == "BOOLEAN":\r
            self.StorageWidth = 1\r
        elif self.PcdDataType == "UINT16":\r
            self.StorageWidth = 2\r
        elif self.PcdDataType == "UINT32":\r
            self.StorageWidth = 4\r
        elif self.PcdDataType == "UINT64":\r
            self.StorageWidth = 8\r
        else:\r
            self.StorageWidth = 0\r
            self.ValidData = False\r
            \r
    def __eq__(self, validObj):       \r
        if self.VarOffset == validObj.VarOffset:\r
            return True\r
        else:\r
            return False\r
         \r
class VAR_CHECK_PCD_VALID_LIST(VAR_CHECK_PCD_VALID_OBJ):\r
    def __init__(self, VarOffset, validlist, PcdDataType):\r
        super(VAR_CHECK_PCD_VALID_LIST, self).__init__(VarOffset, validlist, PcdDataType)\r
        self.Type = 1\r
        self.update_data()\r
        self.update_size()\r
    def update_data(self):\r
        valid_num_list = []\r
        data_list = []\r
        for item in self.rawdata:\r
            valid_num_list.extend(item.split(','))\r
        \r
        for valid_num in valid_num_list:\r
            valid_num = valid_num.strip()\r
\r
            if valid_num.startswith('0x') or valid_num.startswith('0X'):\r
                data_list.append(int(valid_num, 16))\r
            else:\r
                data_list.append(int(valid_num))\r
\r
                \r
        self.data = set(data_list)\r
        \r
    def update_size(self):\r
        self.Length = 5 + len(self.data) * self.StorageWidth\r
        \r
           \r
class VAR_CHECK_PCD_VALID_RANGE(VAR_CHECK_PCD_VALID_OBJ):\r
    def __init__(self, VarOffset, validrange, PcdDataType):\r
        super(VAR_CHECK_PCD_VALID_RANGE, self).__init__(VarOffset, validrange, PcdDataType)\r
        self.Type = 2\r
        self.update_data()\r
        self.update_size()\r
    def update_data(self):\r
        RangeExpr = ""\r
        data_list = []\r
        i = 0\r
        for item in self.rawdata:\r
            if i == 0:\r
                RangeExpr = "( " + item + " )"\r
            else:\r
                RangeExpr = RangeExpr + "OR ( " + item + " )"\r
        range_result = RangeExpression(RangeExpr, self.PcdDataType)(True)\r
        for rangelist in range_result:\r
            for obj in rangelist.pop():\r
                data_list.append((obj.start, obj.end))\r
        self.data = set(data_list)\r
    \r
    def update_size(self):\r
        self.Length = 5 + len(self.data) * 2 * self.StorageWidth\r
        \r
\r
class VAR_VALID_OBJECT_FACTORY(object):\r
    def __init__(self):\r
        pass\r
    @staticmethod\r
    def Get_valid_object(PcdClass, VarOffset):\r
        if PcdClass.validateranges:\r
            return VAR_CHECK_PCD_VALID_RANGE(VarOffset, PcdClass.validateranges, PcdClass.DatumType)\r
        if PcdClass.validlists:\r
            return VAR_CHECK_PCD_VALID_LIST(VarOffset, PcdClass.validlists, PcdClass.DatumType)\r
        else:\r
            return None\r
\r
if __name__ == "__main__":\r
    class TestObj(object):\r
        def __init__(self, number1):\r
            self.number_1 = number1\r
        def __eq__(self, testobj):\r
            if self.number_1 == testobj.number_1:\r
                return True\r
            else:\r
                return False\r
    test1 = TestObj(1)\r
    test2 = TestObj(2)\r
    \r
    testarr = [test1, test2]\r
    print TestObj(2) in testarr\r
    print TestObj(2) == test2\r
    \r
Commit	Line	Data
82a6a960 BF	1	# Copyright (c) 2015, Intel Corporation. All rights reserved.<BR>\r
	2	# This program and the accompanying materials\r
	3	# are licensed and made available under the terms and conditions of the BSD License\r
	4	# which accompanies this distribution. The full text of the license may be found at\r
	5	# http://opensource.org/licenses/bsd-license.php\r
	6	#\r
	7	# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
	8	# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
	9	\r
	10	#\r
	11	# This file is used to collect the Variable checking information\r
	12	#\r
	13	\r
	14	# #\r
	15	# Import Modules\r
	16	#\r
	17	import os\r
	18	from Common.RangeExpression import RangeExpression\r
	19	from Common.Misc import *\r
	20	from StringIO import StringIO\r
	21	from struct import pack\r
	22	\r
	23	class VAR_CHECK_PCD_VARIABLE_TAB_CONTAINER(object):\r
	24	def __init__(self):\r
	25	self.var_check_info = []\r
	26	\r
	27	def push_back(self, var_check_tab):\r
	28	for tab in self.var_check_info:\r
	29	if tab.equal(var_check_tab):\r
	30	tab.merge(var_check_tab)\r
	31	break\r
	32	else:\r
	33	self.var_check_info.append(var_check_tab)\r
072418e5	34	\r
82a6a960 BF	35	def dump(self, dest, Phase):\r
	36	\r
	37	FormatMap = {}\r
	38	FormatMap[1] = "=B"\r
	39	FormatMap[2] = "=H"\r
	40	FormatMap[4] = "=L"\r
	41	FormatMap[8] = "=Q"\r
	42	\r
	43	if not os.path.isabs(dest):\r
	44	return\r
	45	if not os.path.exists(dest):\r
	46	os.mkdir(dest)\r
	47	BinFileName = "PcdVarCheck.bin"\r
	48	BinFilePath = os.path.join(dest, BinFileName)\r
	49	Buffer = ''\r
	50	index = 0\r
	51	for var_check_tab in self.var_check_info:\r
	52	index += 1\r
	53	realLength = 0\r
	54	realLength += 32\r
	55	Name = var_check_tab.Name[1:-1]\r
	56	NameChars = Name.split(",")\r
	57	realLength += len(NameChars)\r
	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):\r
	59	realLength += (4 - (realLength % 4))\r
	60	itemIndex = 0\r
	61	for item in var_check_tab.validtab:\r
	62	itemIndex += 1\r
	63	realLength += 5\r
	64	for v_data in item.data:\r
072418e5	65	if type(v_data) in (int, long):\r
82a6a960 BF	66	realLength += item.StorageWidth\r
	67	else:\r
	68	realLength += item.StorageWidth\r
	69	realLength += item.StorageWidth\r
	70	if (index == len(self.var_check_info)) :\r
	71	if (itemIndex < len(var_check_tab.validtab)) and realLength % 4:\r
	72	realLength += (4 - (realLength % 4))\r
	73	else:\r
	74	if realLength % 4:\r
	75	realLength += (4 - (realLength % 4))\r
	76	var_check_tab.Length = realLength\r
	77	realLength = 0\r
	78	index = 0\r
	79	for var_check_tab in self.var_check_info:\r
	80	index += 1\r
	81	\r
	82	b = pack("=H", var_check_tab.Revision)\r
	83	Buffer += b\r
	84	realLength += 2\r
	85	\r
	86	b = pack("=H", var_check_tab.HeaderLength)\r
	87	Buffer += b\r
	88	realLength += 2\r
	89	\r
	90	b = pack("=L", var_check_tab.Length)\r
	91	Buffer += b\r
	92	realLength += 4\r
	93	\r
	94	b = pack("=B", var_check_tab.Type)\r
	95	Buffer += b\r
	96	realLength += 1\r
	97	\r
	98	for i in range(0, 3):\r
	99	b = pack("=B", var_check_tab.Reserved)\r
	100	Buffer += b\r
	101	realLength += 1\r
	102	\r
	103	b = pack("=L", var_check_tab.Attributes)\r
	104	Buffer += b\r
	105	realLength += 4\r
	106	\r
	107	Guid = var_check_tab.Guid\r
	108	b = pack('=LHHBBBBBBBB',\r
	109	Guid[0],\r
	110	Guid[1],\r
	111	Guid[2],\r
	112	Guid[3],\r
	113	Guid[4],\r
	114	Guid[5],\r
	115	Guid[6],\r
	116	Guid[7],\r
	117	Guid[8],\r
	118	Guid[9],\r
	119	Guid[10],\r
	120	)\r
	121	Buffer += b\r
	122	realLength += 16\r
	123	\r
	124	Name = var_check_tab.Name[1:-1]\r
	125	NameChars = Name.split(",")\r
	126	for NameChar in NameChars:\r
	127	NameCharNum = int(NameChar, 16)\r
	128	b = pack("=B", NameCharNum)\r
	129	Buffer += b\r
130	realLength += 1\r
131	\r
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):\r
133	for i in range(4 - (realLength % 4)):\r
134	b = pack("=B", var_check_tab.pad)\r
135	Buffer += b\r
136	realLength += 1\r
137	itemIndex = 0\r
138	for item in var_check_tab.validtab:\r
139	itemIndex += 1\r
140	\r
141	b = pack("=B", item.Type)\r
142	Buffer += b\r
143	realLength += 1\r
144	\r
145	b = pack("=B", item.Length)\r
146	Buffer += b\r
147	realLength += 1\r
148	\r
149	b = pack("=H", int(item.VarOffset, 16))\r
150	Buffer += b\r
151	realLength += 2\r
152	\r
153	b = pack("=B", item.StorageWidth)\r
154	Buffer += b\r
155	realLength += 1\r
82a6a960	156	for v_data in item.data:\r
072418e5	157	if type(v_data) in (int, long):\r
82a6a960 BF	158	b = pack(FormatMap[item.StorageWidth], v_data)\r
	159	Buffer += b\r
	160	realLength += item.StorageWidth\r
	161	else:\r
	162	b = pack(FormatMap[item.StorageWidth], v_data[0])\r
	163	Buffer += b\r
	164	realLength += item.StorageWidth\r
	165	b = pack(FormatMap[item.StorageWidth], v_data[1])\r
	166	Buffer += b\r
	167	realLength += item.StorageWidth\r
	168	\r
	169	if (index == len(self.var_check_info)) :\r
	170	if (itemIndex < len(var_check_tab.validtab)) and realLength % 4:\r
	171	for i in range(4 - (realLength % 4)):\r
	172	b = pack("=B", var_check_tab.pad)\r
	173	Buffer += b\r
	174	realLength += 1\r
	175	else:\r
	176	if realLength % 4:\r
	177	for i in range(4 - (realLength % 4)):\r
	178	b = pack("=B", var_check_tab.pad)\r
	179	Buffer += b\r
	180	realLength += 1\r
	181	\r
	182	DbFile = StringIO()\r
	183	if Phase == 'DXE' and os.path.exists(BinFilePath):\r
	184	BinFile = open(BinFilePath, "rb")\r
	185	BinBuffer = BinFile.read()\r
	186	BinFile.close()\r
	187	BinBufferSize = len(BinBuffer)\r
	188	if (BinBufferSize % 4):\r
	189	for i in range(4 - (BinBufferSize % 4)):\r
	190	b = pack("=B", VAR_CHECK_PCD_VARIABLE_TAB.pad)\r
	191	BinBuffer += b\r
	192	Buffer = BinBuffer + Buffer\r
	193	DbFile.write(Buffer)\r
	194	SaveFileOnChange(BinFilePath, DbFile.getvalue(), True)\r
	195	\r
	196	\r
	197	class VAR_CHECK_PCD_VARIABLE_TAB(object):\r
	198	pad = 0xDA\r
	199	def __init__(self, TokenSpaceGuid, PcdCName):\r
	200	self.Revision = 0x0001\r
	201	self.HeaderLength = 0\r
	202	self.Length = 0 # Length include this header\r
	203	self.Type = 0\r
	204	self.Reserved = 0\r
	205	self.Attributes = 0x00000000\r
	206	self.Guid = eval("[" + TokenSpaceGuid.replace("{", "").replace("}", "") + "]")\r
	207	self.Name = PcdCName\r
	208	self.validtab = []\r
	209	\r
	210	def UpdateSize(self):\r
	211	self.HeaderLength = 32 + len(self.Name.split(","))\r
	212	self.Length = 32 + len(self.Name.split(",")) + self.GetValidTabLen()\r
	213	\r
	214	def GetValidTabLen(self):\r
	215	validtablen = 0\r
	216	for item in self.validtab:\r
	217	validtablen += item.Length \r
	218	return validtablen \r
	219	\r
	220	def SetAttributes(self, attributes):\r
	221	self.Attributes = attributes\r
222	\r
223	def push_back(self, valid_obj):\r
224	if valid_obj is not None:\r
225	self.validtab.append(valid_obj)\r
226	\r
227	def equal(self, varchecktab):\r
228	if self.Guid == varchecktab.Guid and self.Name == varchecktab.Name:\r
229	return True\r
230	else:\r
231	return False\r
232	\r
233	def merge(self, varchecktab):\r
234	for validobj in varchecktab.validtab:\r
235	if validobj in self.validtab:\r
236	continue\r
237	self.validtab.append(validobj)\r
238	self.UpdateSize()\r
239	\r
240	\r
241	class VAR_CHECK_PCD_VALID_OBJ(object):\r
242	def __init__(self, VarOffset, data, PcdDataType):\r
243	self.Type = 1\r
244	self.Length = 0 # Length include this header\r
245	self.VarOffset = VarOffset\r
246	self.StorageWidth = 0\r
247	self.PcdDataType = PcdDataType.strip()\r
248	self.rawdata = data\r
249	self.data = set()\r
250	self.ValidData = True\r
251	self.updateStorageWidth()\r
252	def updateStorageWidth(self):\r
253	if self.PcdDataType == "UINT8" or self.PcdDataType == "BOOLEAN":\r
254	self.StorageWidth = 1\r
255	elif self.PcdDataType == "UINT16":\r
256	self.StorageWidth = 2\r
257	elif self.PcdDataType == "UINT32":\r
258	self.StorageWidth = 4\r
259	elif self.PcdDataType == "UINT64":\r
260	self.StorageWidth = 8\r
261	else:\r
262	self.StorageWidth = 0\r
263	self.ValidData = False\r
264	\r
265	def __eq__(self, validObj): \r
266	if self.VarOffset == validObj.VarOffset:\r
267	return True\r
268	else:\r
269	return False\r
270	\r
271	class VAR_CHECK_PCD_VALID_LIST(VAR_CHECK_PCD_VALID_OBJ):\r
272	def __init__(self, VarOffset, validlist, PcdDataType):\r
273	super(VAR_CHECK_PCD_VALID_LIST, self).__init__(VarOffset, validlist, PcdDataType)\r
274	self.Type = 1\r
275	self.update_data()\r
276	self.update_size()\r
277	def update_data(self):\r
278	valid_num_list = []\r
279	data_list = []\r
280	for item in self.rawdata:\r
281	valid_num_list.extend(item.split(','))\r
282	\r
283	for valid_num in valid_num_list:\r
284	valid_num = valid_num.strip()\r
285	\r
286	if valid_num.startswith('0x') or valid_num.startswith('0X'):\r
287	data_list.append(int(valid_num, 16))\r
288	else:\r
289	data_list.append(int(valid_num))\r
290	\r
291	\r
292	self.data = set(data_list)\r
293	\r
294	def update_size(self):\r
295	self.Length = 5 + len(self.data) * self.StorageWidth\r
296	\r
297	\r
298	class VAR_CHECK_PCD_VALID_RANGE(VAR_CHECK_PCD_VALID_OBJ):\r
299	def __init__(self, VarOffset, validrange, PcdDataType):\r
300	super(VAR_CHECK_PCD_VALID_RANGE, self).__init__(VarOffset, validrange, PcdDataType)\r
301	self.Type = 2\r
302	self.update_data()\r
303	self.update_size()\r
304	def update_data(self):\r
305	RangeExpr = ""\r
306	data_list = []\r
307	i = 0\r
308	for item in self.rawdata:\r
309	if i == 0:\r
310	RangeExpr = "( " + item + " )"\r
311	else:\r
312	RangeExpr = RangeExpr + "OR ( " + item + " )"\r
313	range_result = RangeExpression(RangeExpr, self.PcdDataType)(True)\r
314	for rangelist in range_result:\r
315	for obj in rangelist.pop():\r
316	data_list.append((obj.start, obj.end))\r
317	self.data = set(data_list)\r
318	\r
319	def update_size(self):\r
320	self.Length = 5 + len(self.data) * 2 * self.StorageWidth\r
321	\r
322	\r
323	class VAR_VALID_OBJECT_FACTORY(object):\r
324	def __init__(self):\r
325	pass\r
326	@staticmethod\r
327	def Get_valid_object(PcdClass, VarOffset):\r
328	if PcdClass.validateranges:\r
329	return VAR_CHECK_PCD_VALID_RANGE(VarOffset, PcdClass.validateranges, PcdClass.DatumType)\r
330	if PcdClass.validlists:\r
331	return VAR_CHECK_PCD_VALID_LIST(VarOffset, PcdClass.validlists, PcdClass.DatumType)\r
332	else:\r
333	return None\r
334	\r
335	if __name__ == "__main__":\r
336	class TestObj(object):\r
337	def __init__(self, number1):\r
338	self.number_1 = number1\r
339	def __eq__(self, testobj):\r
340	if self.number_1 == testobj.number_1:\r
341	return True\r
342	else:\r
343	return False\r
344	test1 = TestObj(1)\r
345	test2 = TestObj(2)\r
346	\r
347	testarr = [test1, test2]\r
348	print TestObj(2) in testarr\r
349	print TestObj(2) == test2\r
350	\r