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

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