# 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
-from StringIO import StringIO\r
+from __future__ import absolute_import\r
+from io import BytesIO\r
from Common.Misc import *\r
from Common.StringUtils import StringToArray\r
from struct import pack\r
-from ValidCheckingInfoObject import VAR_CHECK_PCD_VARIABLE_TAB_CONTAINER\r
-from ValidCheckingInfoObject import VAR_CHECK_PCD_VARIABLE_TAB\r
-from ValidCheckingInfoObject import GetValidationObject\r
+from .ValidCheckingInfoObject import VAR_CHECK_PCD_VARIABLE_TAB_CONTAINER\r
+from .ValidCheckingInfoObject import VAR_CHECK_PCD_VARIABLE_TAB\r
+from .ValidCheckingInfoObject import GetValidationObject\r
from Common.VariableAttributes import VariableAttributes\r
import copy\r
from struct import unpack\r
from Common.DataType import *\r
+from Common import GlobalData\r
+from Common import EdkLogger\r
+import Common.LongFilePathOs as os\r
\r
DATABASE_VERSION = 7\r
\r
//UINT32 UninitDataBaseSize;// Total size for PCD those default value with 0.\r
//TABLE_OFFSET LocalTokenNumberTableOffset;\r
//TABLE_OFFSET ExMapTableOffset;\r
- //TABLE_OFFSET GuidTableOffset; \r
+ //TABLE_OFFSET GuidTableOffset;\r
//TABLE_OFFSET StringTableOffset;\r
//TABLE_OFFSET SizeTableOffset;\r
- //TABLE_OFFSET SkuIdTableOffset; \r
+ //TABLE_OFFSET SkuIdTableOffset;\r
//TABLE_OFFSET PcdNameTableOffset;\r
//UINT16 LocalTokenCount; // LOCAL_TOKEN_NUMBER for all\r
//UINT16 ExTokenCount; // EX_TOKEN_NUMBER for DynamicEx\r
\r
## DbItemList\r
#\r
-# The class holds the Pcd database items. ItemSize if not zero should match the item datum type in the C structure. \r
+# The class holds the Pcd database items. ItemSize if not zero should match the item datum type in the C structure.\r
# When the structure is changed, remember to check the ItemSize and the related PackStr in PackData()\r
-# RawDataList is the RawData that may need some kind of calculation or transformation, \r
+# RawDataList is the RawData that may need some kind of calculation or transformation,\r
# the DataList corresponds to the data that need to be written to database. If DataList is not present, then RawDataList\r
-# will be written to the database. \r
+# will be written to the database.\r
#\r
class DbItemList:\r
def __init__(self, ItemSize, DataList=None, RawDataList=None):\r
# Variable length, need to calculate one by one\r
#\r
assert(Index < len(self.RawDataList))\r
- for ItemIndex in xrange(Index):\r
+ for ItemIndex in range(Index):\r
Offset += len(self.RawDataList[ItemIndex])\r
else:\r
Offset = self.ItemSize * Index\r
\r
PackStr = PACK_CODE_BY_SIZE[self.ItemSize]\r
\r
- Buffer = ''\r
+ Buffer = bytearray()\r
for Datas in self.RawDataList:\r
if type(Datas) in (list, tuple):\r
for Data in Datas:\r
\r
## DbExMapTblItemList\r
#\r
-# The class holds the ExMap table \r
+# The class holds the ExMap table\r
#\r
class DbExMapTblItemList (DbItemList):\r
def __init__(self, ItemSize, DataList=None, RawDataList=None):\r
DbItemList.__init__(self, ItemSize, DataList, RawDataList)\r
\r
def PackData(self):\r
- Buffer = ''\r
+ Buffer = bytearray()\r
PackStr = "=LHH"\r
for Datas in self.RawDataList:\r
- Buffer += pack(PackStr, \r
+ Buffer += pack(PackStr,\r
GetIntegerValue(Datas[0]),\r
GetIntegerValue(Datas[1]),\r
- GetIntegerValue(Datas[2])) \r
+ GetIntegerValue(Datas[2]))\r
return Buffer\r
\r
## DbComItemList\r
#\r
-# The DbComItemList is a special kind of DbItemList in case that the size of the List can not be computed by the \r
+# The DbComItemList is a special kind of DbItemList in case that the size of the List can not be computed by the\r
# ItemSize multiply the ItemCount.\r
#\r
class DbComItemList (DbItemList):\r
Offset = 0\r
if self.ItemSize == 0:\r
#\r
- # Variable length, need to calculte one by one\r
+ # Variable length, need to calculate one by one\r
# The only variable table is stringtable, it is not Composite item, should not reach here\r
#\r
assert(False)\r
else:\r
assert(Index < len(self.RawDataList))\r
- for ItemIndex in xrange(Index):\r
- Offset += len(self.RawDataList[ItemIndex]) * self.ItemSize \r
+ for ItemIndex in range(Index):\r
+ Offset += len(self.RawDataList[ItemIndex]) * self.ItemSize\r
\r
return Offset\r
\r
def PackData(self):\r
PackStr = PACK_CODE_BY_SIZE[self.ItemSize]\r
\r
- Buffer = ''\r
+ Buffer = bytearray()\r
for DataList in self.RawDataList:\r
for Data in DataList:\r
if type(Data) in (list, tuple):\r
Buffer += pack(PackStr, GetIntegerValue(SingleData))\r
else:\r
Buffer += pack(PackStr, GetIntegerValue(Data))\r
- \r
+\r
return Buffer\r
\r
## DbVariableTableItemList\r
#\r
-# The class holds the Variable header value table \r
+# The class holds the Variable header value table\r
#\r
class DbVariableTableItemList (DbComItemList):\r
def __init__(self, ItemSize, DataList=None, RawDataList=None):\r
\r
def PackData(self):\r
PackStr = "=LLHHLHH"\r
- Buffer = ''\r
+ Buffer = bytearray()\r
for DataList in self.RawDataList:\r
for Data in DataList:\r
- Buffer += pack(PackStr, \r
+ Buffer += pack(PackStr,\r
GetIntegerValue(Data[0]),\r
GetIntegerValue(Data[1]),\r
GetIntegerValue(Data[2]),\r
class DbStringHeadTableItemList(DbItemList):\r
def __init__(self,ItemSize,DataList=None,RawDataList=None):\r
DbItemList.__init__(self, ItemSize, DataList, RawDataList)\r
- \r
+\r
def GetInterOffset(self, Index):\r
Offset = 0\r
if self.ItemSize == 0:\r
# Variable length, need to calculate one by one\r
#\r
assert(Index < len(self.RawDataList))\r
- for ItemIndex in xrange(Index):\r
+ for ItemIndex in range(Index):\r
Offset += len(self.RawDataList[ItemIndex])\r
else:\r
for innerIndex in range(Index):\r
self.ListSize += len(Datas) * self.ItemSize\r
else:\r
self.ListSize += self.ItemSize\r
- return self.ListSize \r
+ return self.ListSize\r
\r
## DbSkuHeadTableItemList\r
#\r
-# The class holds the Sku header value table \r
+# The class holds the Sku header value table\r
#\r
class DbSkuHeadTableItemList (DbItemList):\r
def __init__(self, ItemSize, DataList=None, RawDataList=None):\r
\r
def PackData(self):\r
PackStr = "=LL"\r
- Buffer = ''\r
+ Buffer = bytearray()\r
for Data in self.RawDataList:\r
- Buffer += pack(PackStr, \r
+ Buffer += pack(PackStr,\r
GetIntegerValue(Data[0]),\r
GetIntegerValue(Data[1]))\r
return Buffer\r
\r
## DbSizeTableItemList\r
#\r
-# The class holds the size table \r
+# The class holds the size table\r
#\r
class DbSizeTableItemList (DbItemList):\r
def __init__(self, ItemSize, DataList=None, RawDataList=None):\r
return length * self.ItemSize\r
def PackData(self):\r
PackStr = "=H"\r
- Buffer = ''\r
+ Buffer = bytearray()\r
for Data in self.RawDataList:\r
- Buffer += pack(PackStr, \r
+ Buffer += pack(PackStr,\r
GetIntegerValue(Data[0]))\r
for subData in Data[1]:\r
- Buffer += pack(PackStr, \r
+ Buffer += pack(PackStr,\r
GetIntegerValue(subData))\r
return Buffer\r
\r
## DbStringItemList\r
#\r
-# The class holds the string table \r
+# The class holds the string table\r
#\r
class DbStringItemList (DbComItemList):\r
def __init__(self, ItemSize, DataList=None, RawDataList=None, LenList=None):\r
RawDataList = []\r
if LenList is None:\r
LenList = []\r
- \r
+\r
assert(len(RawDataList) == len(LenList))\r
DataList = []\r
# adjust DataList according to the LenList\r
- for Index in xrange(len(RawDataList)):\r
+ for Index in range(len(RawDataList)):\r
Len = LenList[Index]\r
RawDatas = RawDataList[Index]\r
assert(Len >= len(RawDatas))\r
ActualDatas = []\r
- for i in xrange(len(RawDatas)):\r
+ for i in range(len(RawDatas)):\r
ActualDatas.append(RawDatas[i])\r
- for i in xrange(len(RawDatas), Len):\r
+ for i in range(len(RawDatas), Len):\r
ActualDatas.append(0)\r
DataList.append(ActualDatas)\r
self.LenList = LenList\r
Offset = 0\r
\r
assert(Index < len(self.LenList))\r
- for ItemIndex in xrange(Index):\r
+ for ItemIndex in range(Index):\r
Offset += self.LenList[ItemIndex]\r
\r
return Offset\r
return Index\r
else:\r
StartPos = Index + 1\r
- \r
+\r
return -1\r
\r
\r
# to List like [0x36, 0x00, 0x34, 0x00, 0x21, 0x00, 0x36, 0x00, 0x34, 0x00, 0x00, 0x00]\r
#\r
# @param StringArray A string array like {0x36, 0x00, 0x34, 0x00, 0x21, 0x00, 0x36, 0x00, 0x34, 0x00, 0x00, 0x00}\r
-# \r
+#\r
# @retval A list object of integer items\r
#\r
def StringArrayToList(StringArray):\r
## Convert TokenType String like "PCD_DATUM_TYPE_UINT32 | PCD_TYPE_HII" to TokenType value\r
#\r
# @param TokenType A TokenType string like "PCD_DATUM_TYPE_UINT32 | PCD_TYPE_HII"\r
-# \r
+#\r
# @retval A integer representation of the TokenType\r
#\r
def GetTokenTypeValue(TokenType):\r
## construct the external Pcd database using data from Dict\r
#\r
# @param Dict A dictionary contains Pcd related tables\r
-# \r
+#\r
# @retval Buffer A byte stream of the Pcd database\r
#\r
def BuildExDataBase(Dict):\r
DbVardefValueUint32 = DbItemList(4, RawDataList = VardefValueUint32)\r
VpdHeadValue = Dict['VPD_DB_VALUE']\r
DbVpdHeadValue = DbComItemList(4, RawDataList = VpdHeadValue)\r
- ExMapTable = zip(Dict['EXMAPPING_TABLE_EXTOKEN'], Dict['EXMAPPING_TABLE_LOCAL_TOKEN'], Dict['EXMAPPING_TABLE_GUID_INDEX'])\r
+ ExMapTable = list(zip(Dict['EXMAPPING_TABLE_EXTOKEN'], Dict['EXMAPPING_TABLE_LOCAL_TOKEN'], Dict['EXMAPPING_TABLE_GUID_INDEX']))\r
DbExMapTable = DbExMapTblItemList(8, RawDataList = ExMapTable)\r
LocalTokenNumberTable = Dict['LOCAL_TOKEN_NUMBER_DB_VALUE']\r
DbLocalTokenNumberTable = DbItemList(4, RawDataList = LocalTokenNumberTable)\r
NumberOfSkuEnabledPcd = GetIntegerValue(Dict['SKU_HEAD_SIZE'])\r
\r
Dict['STRING_TABLE_DB_VALUE'] = [StringArrayToList(x) for x in Dict['STRING_TABLE_VALUE']]\r
- \r
+\r
StringTableValue = Dict['STRING_TABLE_DB_VALUE']\r
- # when calcute the offset, should use StringTableLen instead of StringTableValue, as string maxium len may be different with actual len\r
+ # when calcute the offset, should use StringTableLen instead of StringTableValue, as string maximum len may be different with actual len\r
StringTableLen = Dict['STRING_TABLE_LENGTH']\r
DbStringTableLen = DbStringItemList(0, RawDataList = StringTableValue, LenList = StringTableLen)\r
\r
- \r
+\r
PcdTokenTable = Dict['PCD_TOKENSPACE']\r
PcdTokenLen = Dict['PCD_TOKENSPACE_LENGTH']\r
PcdTokenTableValue = [StringArrayToList(x) for x in Dict['PCD_TOKENSPACE']]\r
DbPcdTokenTable = DbStringItemList(0, RawDataList = PcdTokenTableValue, LenList = PcdTokenLen)\r
- \r
+\r
PcdCNameTable = Dict['PCD_CNAME']\r
PcdCNameLen = Dict['PCD_CNAME_LENGTH']\r
PcdCNameTableValue = [StringArrayToList(x) for x in Dict['PCD_CNAME']]\r
DbPcdCNameTable = DbStringItemList(0, RawDataList = PcdCNameTableValue, LenList = PcdCNameLen)\r
- \r
+\r
PcdNameOffsetTable = Dict['PCD_NAME_OFFSET']\r
DbPcdNameOffsetTable = DbItemList(4, RawDataList = PcdNameOffsetTable)\r
- \r
- SizeTableValue = zip(Dict['SIZE_TABLE_MAXIMUM_LENGTH'], Dict['SIZE_TABLE_CURRENT_LENGTH'])\r
+\r
+ SizeTableValue = list(zip(Dict['SIZE_TABLE_MAXIMUM_LENGTH'], Dict['SIZE_TABLE_CURRENT_LENGTH']))\r
DbSizeTableValue = DbSizeTableItemList(2, RawDataList = SizeTableValue)\r
InitValueUint16 = Dict['INIT_DB_VALUE_UINT16']\r
DbInitValueUint16 = DbComItemList(2, RawDataList = InitValueUint16)\r
DbSkuidValue = DbItemList(8, RawDataList = SkuidValue)\r
\r
\r
- \r
+\r
# Unit Db Items\r
UnInitValueUint64 = Dict['UNINIT_GUID_DECL_UINT64']\r
DbUnInitValueUint64 = DbItemList(8, RawDataList = UnInitValueUint64)\r
UnInitValueBoolean = Dict['UNINIT_GUID_DECL_BOOLEAN']\r
DbUnInitValueBoolean = DbItemList(1, RawDataList = UnInitValueBoolean)\r
PcdTokenNumberMap = Dict['PCD_ORDER_TOKEN_NUMBER_MAP']\r
- \r
+\r
DbNameTotle = ["SkuidValue", "InitValueUint64", "VardefValueUint64", "InitValueUint32", "VardefValueUint32", "VpdHeadValue", "ExMapTable",\r
"LocalTokenNumberTable", "GuidTable", "StringHeadValue", "PcdNameOffsetTable", "VariableTable", "StringTableLen", "PcdTokenTable", "PcdCNameTable",\r
"SizeTableValue", "InitValueUint16", "VardefValueUint16", "InitValueUint8", "VardefValueUint8", "InitValueBoolean",\r
"VardefValueBoolean", "UnInitValueUint64", "UnInitValueUint32", "UnInitValueUint16", "UnInitValueUint8", "UnInitValueBoolean"]\r
- \r
+\r
DbTotal = [SkuidValue, InitValueUint64, VardefValueUint64, InitValueUint32, VardefValueUint32, VpdHeadValue, ExMapTable,\r
LocalTokenNumberTable, GuidTable, StringHeadValue, PcdNameOffsetTable, VariableTable, StringTableLen, PcdTokenTable, PcdCNameTable,\r
SizeTableValue, InitValueUint16, VardefValueUint16, InitValueUint8, VardefValueUint8, InitValueBoolean,\r
DbLocalTokenNumberTable, DbGuidTable, DbStringHeadValue, DbPcdNameOffsetTable, DbVariableTable, DbStringTableLen, DbPcdTokenTable, DbPcdCNameTable,\r
DbSizeTableValue, DbInitValueUint16, DbVardefValueUint16, DbInitValueUint8, DbVardefValueUint8, DbInitValueBoolean,\r
DbVardefValueBoolean, DbUnInitValueUint64, DbUnInitValueUint32, DbUnInitValueUint16, DbUnInitValueUint8, DbUnInitValueBoolean]\r
- \r
+\r
# VardefValueBoolean is the last table in the init table items\r
InitTableNum = DbNameTotle.index("VardefValueBoolean") + 1\r
# The FixedHeader length of the PCD_DATABASE_INIT, from Signature to Pad\r
FixedHeaderLen = 80\r
\r
- # Get offset of SkuId table in the database \r
+ # Get offset of SkuId table in the database\r
SkuIdTableOffset = FixedHeaderLen\r
- for DbIndex in xrange(len(DbTotal)):\r
+ for DbIndex in range(len(DbTotal)):\r
if DbTotal[DbIndex] is SkuidValue:\r
break\r
SkuIdTableOffset += DbItemTotal[DbIndex].GetListSize()\r
- \r
- \r
- # Get offset of SkuValue table in the database \r
+\r
+\r
+ # Get offset of SkuValue table in the database\r
\r
# Fix up the LocalTokenNumberTable, SkuHeader table\r
for (LocalTokenNumberTableIndex, (Offset, Table)) in enumerate(LocalTokenNumberTable):\r
DbIndex = 0\r
DbOffset = FixedHeaderLen\r
- for DbIndex in xrange(len(DbTotal)):\r
+ for DbIndex in range(len(DbTotal)):\r
if DbTotal[DbIndex] is Table:\r
DbOffset += DbItemTotal[DbIndex].GetInterOffset(Offset)\r
break\r
TokenTypeValue = GetTokenTypeValue(TokenTypeValue)\r
LocalTokenNumberTable[LocalTokenNumberTableIndex] = DbOffset|int(TokenTypeValue)\r
# if PCD_TYPE_SKU_ENABLED, then we need to fix up the SkuTable\r
- \r
- \r
- \r
\r
- # resolve variable table offset \r
+\r
+\r
+\r
+ # resolve variable table offset\r
for VariableEntries in VariableTable:\r
skuindex = 0\r
for VariableEntryPerSku in VariableEntries:\r
(VariableHeadGuidIndex, VariableHeadStringIndex, SKUVariableOffset, VariableOffset, VariableRefTable, VariableAttribute) = VariableEntryPerSku[:]\r
DbIndex = 0\r
DbOffset = FixedHeaderLen\r
- for DbIndex in xrange(len(DbTotal)):\r
+ for DbIndex in range(len(DbTotal)):\r
if DbTotal[DbIndex] is VariableRefTable:\r
DbOffset += DbItemTotal[DbIndex].GetInterOffset(VariableOffset)\r
break\r
else:\r
assert(False)\r
if isinstance(VariableRefTable[0], list):\r
- DbOffset += skuindex * 4 \r
+ DbOffset += skuindex * 4\r
skuindex += 1\r
if DbIndex >= InitTableNum:\r
assert(False)\r
\r
# calculate various table offset now\r
DbTotalLength = FixedHeaderLen\r
- for DbIndex in xrange(len(DbItemTotal)):\r
+ for DbIndex in range(len(DbItemTotal)):\r
if DbItemTotal[DbIndex] is DbLocalTokenNumberTable:\r
LocalTokenNumberTableOffset = DbTotalLength\r
elif DbItemTotal[DbIndex] is DbExMapTable:\r
\r
DbTotalLength += DbItemTotal[DbIndex].GetListSize()\r
if not Dict['PCD_INFO_FLAG']:\r
- DbPcdNameOffset = 0 \r
+ DbPcdNameOffset = 0\r
LocalTokenCount = GetIntegerValue(Dict['LOCAL_TOKEN_NUMBER'])\r
ExTokenCount = GetIntegerValue(Dict['EX_TOKEN_NUMBER'])\r
GuidTableCount = GetIntegerValue(Dict['GUID_TABLE_SIZE'])\r
SystemSkuId = GetIntegerValue(Dict['SYSTEM_SKU_ID_VALUE'])\r
Pad = 0xDA\r
- \r
+\r
UninitDataBaseSize = 0\r
for Item in (DbUnInitValueUint64, DbUnInitValueUint32, DbUnInitValueUint16, DbUnInitValueUint8, DbUnInitValueBoolean):\r
UninitDataBaseSize += Item.GetListSize()\r
- \r
+\r
if (DbTotalLength - UninitDataBaseSize) % 8:\r
DbTotalLength += (8 - (DbTotalLength - UninitDataBaseSize) % 8)\r
# Construct the database buffer\r
\r
Buffer += b\r
b = pack('=L', ExMapTableOffset)\r
- \r
+\r
Buffer += b\r
b = pack('=L', GuidTableOffset)\r
\r
\r
Buffer += b\r
b = pack('=H', GuidTableCount)\r
- \r
+\r
Buffer += b\r
b = pack('=B', Pad)\r
Buffer += b\r
Buffer += b\r
Buffer += b\r
Buffer += b\r
- \r
+\r
Index = 0\r
for Item in DbItemTotal:\r
Index +=1\r
- b = Item.PackData()\r
- Buffer += b \r
+ packdata = Item.PackData()\r
+ for i in range(len(packdata)):\r
+ Buffer += packdata[i:i + 1]\r
if Index == InitTableNum:\r
if len(Buffer) % 8:\r
for num in range(8 - len(Buffer) % 8):\r
b = pack('=B', Pad)\r
Buffer += b\r
- break \r
+ break\r
return Buffer\r
\r
## Create code for PCD database\r
DbFileName = os.path.join(Info.PlatformInfo.BuildDir, TAB_FV_DIRECTORY, Phase + "PcdDataBase.raw")\r
else:\r
DbFileName = os.path.join(Info.OutputDir, Phase + "PcdDataBase.raw")\r
- DbFile = StringIO()\r
+ DbFile = BytesIO()\r
DbFile.write(PcdDbBuffer)\r
Changed = SaveFileOnChange(DbFileName, DbFile.getvalue(), True)\r
def CreatePcdDataBase(PcdDBData):\r
totallenbuff = pack("=L", totallen)\r
newbuffer = databasebuff[:32]\r
for i in range(4):\r
- newbuffer += totallenbuff[i]\r
+ newbuffer += totallenbuff[i:i+1]\r
for i in range(36, totallen):\r
- newbuffer += databasebuff[i]\r
+ newbuffer += databasebuff[i:i+1]\r
\r
return newbuffer\r
\r
new_pcd = copy.deepcopy(pcd)\r
new_pcd.SkuInfoList = {skuname:pcd.SkuInfoList[skuname]}\r
new_pcd.isinit = 'INIT'\r
- if new_pcd.DatumType in TAB_PCD_CLEAN_NUMERIC_TYPES:\r
+ if new_pcd.DatumType in TAB_PCD_NUMERIC_TYPES:\r
for skuobj in pcd.SkuInfoList.values():\r
if skuobj.DefaultValue:\r
defaultvalue = int(skuobj.DefaultValue, 16) if skuobj.DefaultValue.upper().startswith("0X") else int(skuobj.DefaultValue, 10)\r
for skuname, skuid in DynamicPcdSet_Sku:\r
AdditionalAutoGenH, AdditionalAutoGenC, PcdDbBuffer, VarCheckTab = CreatePcdDatabasePhaseSpecificAutoGen (Platform, DynamicPcdSet_Sku[(skuname, skuid)], Phase)\r
final_data = ()\r
- for item in PcdDbBuffer:\r
- final_data += unpack("B", item)\r
+ for item in range(len(PcdDbBuffer)):\r
+ final_data += unpack("B", PcdDbBuffer[item:item+1])\r
PcdDBData[(skuname, skuid)] = (PcdDbBuffer, final_data)\r
PcdDriverAutoGenData[(skuname, skuid)] = (AdditionalAutoGenH, AdditionalAutoGenC)\r
VarCheckTableData[(skuname, skuid)] = VarCheckTab\r
else:\r
AdditionalAutoGenH, AdditionalAutoGenC, PcdDbBuffer, VarCheckTab = CreatePcdDatabasePhaseSpecificAutoGen (Platform, {}, Phase)\r
final_data = ()\r
- for item in PcdDbBuffer:\r
- final_data += unpack("B", item)\r
+ for item in range(len(PcdDbBuffer)):\r
+ final_data += unpack("B", PcdDbBuffer[item:item + 1])\r
PcdDBData[(TAB_DEFAULT, "0")] = (PcdDbBuffer, final_data)\r
\r
return AdditionalAutoGenH, AdditionalAutoGenC, CreatePcdDataBase(PcdDBData)\r
'SKUID_TABLE_EMPTY' : 'TRUE',\r
'DATABASE_EMPTY' : 'TRUE',\r
'EXMAP_TABLE_EMPTY' : 'TRUE',\r
- 'PCD_DATABASE_UNINIT_EMPTY' : ' UINT8 dummy; /* PCD_DATABASE_UNINIT is emptry */',\r
+ 'PCD_DATABASE_UNINIT_EMPTY' : ' UINT8 dummy; /* PCD_DATABASE_UNINIT is empty */',\r
'SYSTEM_SKU_ID' : ' SKU_ID SystemSkuId;',\r
'SYSTEM_SKU_ID_VALUE' : '0U'\r
}\r
- \r
+\r
SkuObj = Platform.Platform.SkuIdMgr\r
Dict['SYSTEM_SKU_ID_VALUE'] = 0 if SkuObj.SkuUsageType == SkuObj.SINGLE else Platform.Platform.SkuIds[SkuObj.SystemSkuId][0]\r
\r
Dict[Init+'_NUMSKUS_DECL_' + DatumType] = []\r
Dict[Init+'_VALUE_' + DatumType] = []\r
Dict[Init+'_DB_VALUE_'+DatumType] = []\r
- \r
+\r
for Type in ['STRING_HEAD', 'VPD_HEAD', 'VARIABLE_HEAD']:\r
Dict[Type + '_CNAME_DECL'] = []\r
Dict[Type + '_GUID_DECL'] = []\r
Dict['STRING_DB_VALUE'] = []\r
Dict['VPD_DB_VALUE'] = []\r
Dict['VARIABLE_DB_VALUE'] = []\r
- \r
+\r
Dict['STRING_TABLE_INDEX'] = []\r
Dict['STRING_TABLE_LENGTH'] = []\r
Dict['STRING_TABLE_CNAME'] = []\r
\r
Dict['LOCAL_TOKEN_NUMBER_DB_VALUE'] = []\r
Dict['VARIABLE_DB_VALUE'] = []\r
- \r
+\r
Dict['PCD_TOKENSPACE'] = []\r
- Dict['PCD_CNAME'] = [] \r
+ Dict['PCD_CNAME'] = []\r
Dict['PCD_TOKENSPACE_LENGTH'] = []\r
Dict['PCD_CNAME_LENGTH'] = []\r
Dict['PCD_TOKENSPACE_OFFSET'] = []\r
Dict['PCD_CNAME_OFFSET'] = []\r
Dict['PCD_TOKENSPACE_MAP'] = []\r
Dict['PCD_NAME_OFFSET'] = []\r
- \r
+\r
Dict['PCD_ORDER_TOKEN_NUMBER_MAP'] = {}\r
PCD_STRING_INDEX_MAP = {}\r
- \r
+\r
StringTableIndex = 0\r
StringTableSize = 0\r
NumberOfLocalTokens = 0\r
\r
if len(Pcd.SkuInfoList) > 1:\r
NumberOfSkuEnabledPcd += 1\r
- \r
- SkuIdIndex = 1 \r
+\r
+ SkuIdIndex = 1\r
VariableHeadList = []\r
for SkuName in Pcd.SkuInfoList:\r
Sku = Pcd.SkuInfoList[SkuName]\r
if SkuId is None or SkuId == '':\r
continue\r
\r
- \r
+\r
SkuIdIndex += 1\r
- \r
+\r
if len(Sku.VariableName) > 0:\r
VariableGuidStructure = Sku.VariableGuidValue\r
VariableGuid = GuidStructureStringToGuidValueName(VariableGuidStructure)\r
# and calculate the VariableHeadStringIndex\r
\r
VariableNameStructure = StringToArray(Sku.VariableName)\r
+\r
+ # Make pointer of VaraibleName(HII PCD) 2 bytes aligned\r
+ VariableNameStructureBytes = VariableNameStructure.lstrip("{").rstrip("}").split(",")\r
+ if len(VariableNameStructureBytes) % 2:\r
+ VariableNameStructure = "{%s,0x00}" % ",".join(VariableNameStructureBytes)\r
+\r
if VariableNameStructure not in Dict['STRING_TABLE_VALUE']:\r
Dict['STRING_TABLE_CNAME'].append(CName)\r
Dict['STRING_TABLE_GUID'].append(TokenSpaceGuid)\r
for Index in range(Dict['STRING_TABLE_VALUE'].index(VariableNameStructure)):\r
VariableHeadStringIndex += Dict['STRING_TABLE_LENGTH'][Index]\r
VariableHeadList.append(VariableHeadStringIndex)\r
- \r
+\r
VariableHeadStringIndex = VariableHeadList[SkuIdIndex - 2]\r
# store VariableGuid to GuidTable and get the VariableHeadGuidIndex\r
\r
\r
if "PCD_TYPE_STRING" in Pcd.TokenTypeList:\r
VariableHeadValueList.append('%dU, offsetof(%s_PCD_DATABASE, Init.%s_%s), %dU, %sU' %\r
- (VariableHeadStringIndex, Phase, CName, TokenSpaceGuid, \r
+ (VariableHeadStringIndex, Phase, CName, TokenSpaceGuid,\r
VariableHeadGuidIndex, Sku.VariableOffset))\r
else:\r
VariableHeadValueList.append('%dU, offsetof(%s_PCD_DATABASE, Init.%s_%s_VariableDefault_%s), %dU, %sU' %\r
- (VariableHeadStringIndex, Phase, CName, TokenSpaceGuid, SkuIdIndex, \r
+ (VariableHeadStringIndex, Phase, CName, TokenSpaceGuid, SkuIdIndex,\r
VariableHeadGuidIndex, Sku.VariableOffset))\r
Dict['VARDEF_CNAME_'+Pcd.DatumType].append(CName)\r
Dict['VARDEF_GUID_'+Pcd.DatumType].append(TokenSpaceGuid)\r
# warning under linux building environment.\r
#\r
Dict['VARDEF_DB_VALUE_'+Pcd.DatumType].append(Sku.HiiDefaultValue)\r
- \r
+\r
if Pcd.DatumType == TAB_UINT64:\r
Dict['VARDEF_VALUE_'+Pcd.DatumType].append(Sku.HiiDefaultValue + "ULL")\r
elif Pcd.DatumType in (TAB_UINT32, TAB_UINT16, TAB_UINT8):\r
Pcd.InitString = 'INIT'\r
VpdHeadOffsetList.append(str(Sku.VpdOffset) + 'U')\r
VpdDbOffsetList.append(Sku.VpdOffset)\r
- # Also add the VOID* string of VPD PCD to SizeTable \r
+ # Also add the VOID* string of VPD PCD to SizeTable\r
if Pcd.DatumType == TAB_VOID:\r
NumberOfSizeItems += 1\r
# For VPD type of PCD, its current size is equal to its MAX size.\r
- VoidStarTypeCurrSize = [str(Pcd.MaxDatumSize) + 'U'] \r
+ VoidStarTypeCurrSize = [str(Pcd.MaxDatumSize) + 'U']\r
continue\r
- \r
+\r
if Pcd.DatumType == TAB_VOID:\r
Pcd.TokenTypeList.append('PCD_TYPE_STRING')\r
Pcd.InitString = 'INIT'\r
DefaultValueBinStructure = StringToArray(Sku.DefaultValue)\r
Size = len(Sku.DefaultValue.split(","))\r
Dict['STRING_TABLE_VALUE'].append(DefaultValueBinStructure)\r
- \r
+\r
StringHeadOffsetList.append(str(StringTableSize) + 'U')\r
StringDbOffsetList.append(StringTableSize)\r
if Pcd.MaxDatumSize != '':\r
ValueList.append(Sku.DefaultValue + "U")\r
elif Pcd.DatumType == "BOOLEAN":\r
if Sku.DefaultValue in ["1", "0"]:\r
- ValueList.append(Sku.DefaultValue + "U") \r
+ ValueList.append(Sku.DefaultValue + "U")\r
else:\r
ValueList.append(Sku.DefaultValue)\r
- \r
+\r
DbValueList.append(Sku.DefaultValue)\r
\r
Pcd.TokenTypeList = list(set(Pcd.TokenTypeList))\r
Dict['SIZE_TABLE_GUID'].append(TokenSpaceGuid)\r
Dict['SIZE_TABLE_MAXIMUM_LENGTH'].append(str(Pcd.MaxDatumSize) + 'U')\r
Dict['SIZE_TABLE_CURRENT_LENGTH'].append(VoidStarTypeCurrSize)\r
- \r
- \r
+\r
+\r
\r
if 'PCD_TYPE_HII' in Pcd.TokenTypeList:\r
Dict['VARIABLE_HEAD_CNAME_DECL'].append(CName)\r
else:\r
Dict[Pcd.InitString+'_VALUE_'+Pcd.DatumType].append(', '.join(ValueList))\r
Dict[Pcd.InitString+'_DB_VALUE_'+Pcd.DatumType].append(DbValueList)\r
- \r
+\r
if Phase == 'PEI':\r
NumberOfLocalTokens = NumberOfPeiLocalTokens\r
if Phase == 'DXE':\r
Dict['TOKEN_TYPE'] = ['' for x in range(NumberOfLocalTokens)]\r
Dict['LOCAL_TOKEN_NUMBER_DB_VALUE'] = ['' for x in range(NumberOfLocalTokens)]\r
Dict['PCD_CNAME'] = ['' for x in range(NumberOfLocalTokens)]\r
- Dict['PCD_TOKENSPACE_MAP'] = ['' for x in range(NumberOfLocalTokens)] \r
+ Dict['PCD_TOKENSPACE_MAP'] = ['' for x in range(NumberOfLocalTokens)]\r
Dict['PCD_CNAME_LENGTH'] = [0 for x in range(NumberOfLocalTokens)]\r
SkuEnablePcdIndex = 0\r
for Pcd in ReorderedDynPcdList:\r
EdkLogger.debug(EdkLogger.DEBUG_1, "PCD = %s.%s" % (CName, TokenSpaceGuidCName))\r
EdkLogger.debug(EdkLogger.DEBUG_1, "phase = %s" % Phase)\r
EdkLogger.debug(EdkLogger.DEBUG_1, "GeneratedTokenNumber = %s" % str(GeneratedTokenNumber))\r
- \r
+\r
#\r
# following four Dict items hold the information for LocalTokenNumberTable\r
#\r
Dict['TOKEN_CNAME'][GeneratedTokenNumber] = CName\r
Dict['TOKEN_GUID'][GeneratedTokenNumber] = TokenSpaceGuid\r
Dict['TOKEN_TYPE'][GeneratedTokenNumber] = ' | '.join(Pcd.TokenTypeList)\r
- \r
+\r
if Platform.Platform.PcdInfoFlag:\r
TokenSpaceGuidCNameArray = StringToArray('"' + TokenSpaceGuidCName + '"' )\r
if TokenSpaceGuidCNameArray not in Dict['PCD_TOKENSPACE']:\r
Dict['PCD_TOKENSPACE_MAP'][GeneratedTokenNumber] = Dict['PCD_TOKENSPACE'].index(TokenSpaceGuidCNameArray)\r
CNameBinArray = StringToArray('"' + CName + '"' )\r
Dict['PCD_CNAME'][GeneratedTokenNumber] = CNameBinArray\r
- \r
+\r
Dict['PCD_CNAME_LENGTH'][GeneratedTokenNumber] = len(CNameBinArray.split(","))\r
- \r
- \r
+\r
+\r
Pcd.TokenTypeList = list(set(Pcd.TokenTypeList))\r
\r
# search the Offset and Table, used by LocalTokenNumberTableOffset\r
if Pcd.InitString == 'UNINIT':\r
Table = Dict[Pcd.InitString+'_GUID_DECL_'+Pcd.DatumType]\r
else:\r
- Table = Dict[Pcd.InitString+'_DB_VALUE_'+Pcd.DatumType] \r
+ Table = Dict[Pcd.InitString+'_DB_VALUE_'+Pcd.DatumType]\r
Dict['LOCAL_TOKEN_NUMBER_DB_VALUE'][GeneratedTokenNumber] = (Offset, Table)\r
\r
#\r
Dict['VARDEF_HEADER'][GeneratedTokenNumber] = '_Variable_Header'\r
else:\r
Dict['VARDEF_HEADER'][GeneratedTokenNumber] = ''\r
- \r
- \r
+\r
+\r
if Pcd.Type in PCD_DYNAMIC_EX_TYPE_SET:\r
- \r
+\r
if Phase == 'DXE':\r
GeneratedTokenNumber += NumberOfPeiLocalTokens\r
#\r
# Therefore, 1 is added to GeneratedTokenNumber to generate a PCD Token Number before being inserted\r
# to the EXMAPPING_TABLE.\r
#\r
- \r
+\r
\r
Dict['EXMAPPING_TABLE_EXTOKEN'].append(str(Pcd.TokenValue) + 'U')\r
Dict['EXMAPPING_TABLE_LOCAL_TOKEN'].append(str(GeneratedTokenNumber + 1) + 'U')\r
TokenSpaceIndex = StringTableSize\r
for i in range(Dict['PCD_TOKENSPACE_MAP'][index]):\r
TokenSpaceIndex += Dict['PCD_TOKENSPACE_LENGTH'][i]\r
- Dict['PCD_TOKENSPACE_OFFSET'].append(TokenSpaceIndex) \r
+ Dict['PCD_TOKENSPACE_OFFSET'].append(TokenSpaceIndex)\r
for index in range(len(Dict['PCD_TOKENSPACE'])):\r
StringTableSize += Dict['PCD_TOKENSPACE_LENGTH'][index]\r
StringTableIndex += 1\r
for index in range(len(Dict['PCD_CNAME'])):\r
- Dict['PCD_CNAME_OFFSET'].append(StringTableSize) \r
+ Dict['PCD_CNAME_OFFSET'].append(StringTableSize)\r
Dict['PCD_NAME_OFFSET'].append(Dict['PCD_TOKENSPACE_OFFSET'][index])\r
Dict['PCD_NAME_OFFSET'].append(StringTableSize)\r
StringTableSize += Dict['PCD_CNAME_LENGTH'][index]\r
\r
if NumberOfSizeItems != 0:\r
Dict['SIZE_TABLE_SIZE'] = str(NumberOfSizeItems * 2) + 'U'\r
- \r
- if NumberOfSkuEnabledPcd != 0: \r
+\r
+ if NumberOfSkuEnabledPcd != 0:\r
Dict['SKU_HEAD_SIZE'] = str(NumberOfSkuEnabledPcd) + 'U'\r
- \r
+\r
for AvailableSkuNumber in SkuObj.SkuIdNumberSet:\r
if AvailableSkuNumber not in Dict['SKUID_VALUE']:\r
Dict['SKUID_VALUE'].append(AvailableSkuNumber)\r
Dict['SKUID_VALUE'][0] = len(Dict['SKUID_VALUE']) - 1\r
- \r
+\r
AutoGenH.Append(gPcdDatabaseAutoGenH.Replace(Dict))\r
if NumberOfLocalTokens == 0:\r
AutoGenC.Append(gEmptyPcdDatabaseAutoGenC.Replace(Dict))\r
SizeCurLenTempList = []\r
SizeMaxLenTempList = []\r
ReOrderFlag = True\r
- \r
+\r
if len(Dict['SIZE_TABLE_CNAME']) == 1:\r
if not (Dict['SIZE_TABLE_CNAME'][0] and Dict['SIZE_TABLE_GUID'][0]):\r
ReOrderFlag = False\r
- \r
+\r
if ReOrderFlag:\r
for Count in range(len(Dict['TOKEN_CNAME'])):\r
for Count1 in range(len(Dict['SIZE_TABLE_CNAME'])):\r
SizeGuidTempList.append(Dict['SIZE_TABLE_GUID'][Count1])\r
SizeCurLenTempList.append(Dict['SIZE_TABLE_CURRENT_LENGTH'][Count1])\r
SizeMaxLenTempList.append(Dict['SIZE_TABLE_MAXIMUM_LENGTH'][Count1])\r
- \r
+\r
for Count in range(len(Dict['SIZE_TABLE_CNAME'])):\r
Dict['SIZE_TABLE_CNAME'][Count] = SizeCNameTempList[Count]\r
Dict['SIZE_TABLE_GUID'][Count] = SizeGuidTempList[Count]\r
Dict['SIZE_TABLE_CURRENT_LENGTH'][Count] = SizeCurLenTempList[Count]\r
Dict['SIZE_TABLE_MAXIMUM_LENGTH'][Count] = SizeMaxLenTempList[Count]\r
- \r
+\r
AutoGenC.Append(gPcdDatabaseAutoGenC.Replace(Dict))\r
- \r
+\r
\r
# print Phase\r
Buffer = BuildExDataBase(Dict)\r
projects / mirror_edk2.git / blobdiff