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

## @file\r
# Routines for generating Pcd Database\r
#\r
# Copyright (c) 2013 - 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
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 Common.VariableAttributes import VariableAttributes\r
import copy\r
from struct import unpack\r
from Common.DataType import *\r
\r
DATABASE_VERSION = 7\r
\r
gPcdDatabaseAutoGenC = TemplateString("""\r
//\r
// External PCD database debug information\r
//\r
#if 0\r
${PHASE}_PCD_DATABASE_INIT g${PHASE}PcdDbInit = {\r
  /* SkuIdTable */\r
  { ${BEGIN}${SKUID_VALUE}, ${END} },\r
${BEGIN}  { ${INIT_VALUE_UINT64} }, /*  ${INIT_CNAME_DECL_UINT64}_${INIT_GUID_DECL_UINT64}[${INIT_NUMSKUS_DECL_UINT64}] */\r
${END}\r
${BEGIN}  ${VARDEF_VALUE_UINT64}, /* ${VARDEF_CNAME_UINT64}_${VARDEF_GUID_UINT64}_VariableDefault_${VARDEF_SKUID_UINT64} */\r
${END}\r
${BEGIN}  { ${INIT_VALUE_UINT32} }, /*  ${INIT_CNAME_DECL_UINT32}_${INIT_GUID_DECL_UINT32}[${INIT_NUMSKUS_DECL_UINT32}] */\r
${END}\r
${BEGIN}  ${VARDEF_VALUE_UINT32}, /* ${VARDEF_CNAME_UINT32}_${VARDEF_GUID_UINT32}_VariableDefault_${VARDEF_SKUID_UINT32} */\r
${END}\r
  /* VPD */\r
${BEGIN}  { ${VPD_HEAD_VALUE} }, /* ${VPD_HEAD_CNAME_DECL}_${VPD_HEAD_GUID_DECL}[${VPD_HEAD_NUMSKUS_DECL}] */\r
${END}\r
  /* ExMapTable */\r
  {\r
${BEGIN}    { ${EXMAPPING_TABLE_EXTOKEN}, ${EXMAPPING_TABLE_LOCAL_TOKEN}, ${EXMAPPING_TABLE_GUID_INDEX} },\r
${END}\r
  },\r
  /* LocalTokenNumberTable */\r
  {\r
${BEGIN}    offsetof(${PHASE}_PCD_DATABASE, ${TOKEN_INIT}.${TOKEN_CNAME}_${TOKEN_GUID}${VARDEF_HEADER}) | ${TOKEN_TYPE},\r
${END}\r
  },\r
  /* GuidTable */\r
  {\r
${BEGIN}    ${GUID_STRUCTURE},\r
${END}\r
  },\r
${BEGIN}  { ${STRING_HEAD_VALUE} }, /* ${STRING_HEAD_CNAME_DECL}_${STRING_HEAD_GUID_DECL}[${STRING_HEAD_NUMSKUS_DECL}] */\r
${END}\r
${BEGIN}  /* ${VARIABLE_HEAD_CNAME_DECL}_${VARIABLE_HEAD_GUID_DECL}_Variable_Header[${VARIABLE_HEAD_NUMSKUS_DECL}] */\r
  {\r
    ${VARIABLE_HEAD_VALUE}\r
  },\r
${END}\r
/* SkuHead */\r
  {\r
  ${BEGIN} offsetof (${PHASE}_PCD_DATABASE, ${TOKEN_INIT}.${TOKEN_CNAME}_${TOKEN_GUID}${VARDEF_HEADER}) | ${TOKEN_TYPE}, /* */\r
           offsetof (${PHASE}_PCD_DATABASE, ${TOKEN_INIT}.SkuHead)  /* */\r
  ${END}\r
  },\r
 /* StringTable */\r
${BEGIN}  ${STRING_TABLE_VALUE}, /* ${STRING_TABLE_CNAME}_${STRING_TABLE_GUID} */\r
${END}\r
  /* SizeTable */\r
  {\r
${BEGIN}    ${SIZE_TABLE_MAXIMUM_LENGTH}, ${SIZE_TABLE_CURRENT_LENGTH}, /* ${SIZE_TABLE_CNAME}_${SIZE_TABLE_GUID} */\r
${END}\r
  },\r
${BEGIN}  { ${INIT_VALUE_UINT16} }, /*  ${INIT_CNAME_DECL_UINT16}_${INIT_GUID_DECL_UINT16}[${INIT_NUMSKUS_DECL_UINT16}] */\r
${END}\r
${BEGIN}  ${VARDEF_VALUE_UINT16}, /* ${VARDEF_CNAME_UINT16}_${VARDEF_GUID_UINT16}_VariableDefault_${VARDEF_SKUID_UINT16} */\r
${END}\r
${BEGIN}  { ${INIT_VALUE_UINT8} }, /*  ${INIT_CNAME_DECL_UINT8}_${INIT_GUID_DECL_UINT8}[${INIT_NUMSKUS_DECL_UINT8}] */\r
${END}\r
${BEGIN}  ${VARDEF_VALUE_UINT8}, /* ${VARDEF_CNAME_UINT8}_${VARDEF_GUID_UINT8}_VariableDefault_${VARDEF_SKUID_UINT8} */\r
${END}\r
${BEGIN}  { ${INIT_VALUE_BOOLEAN} }, /*  ${INIT_CNAME_DECL_BOOLEAN}_${INIT_GUID_DECL_BOOLEAN}[${INIT_NUMSKUS_DECL_BOOLEAN}] */\r
${END}\r
${BEGIN}  ${VARDEF_VALUE_BOOLEAN}, /* ${VARDEF_CNAME_BOOLEAN}_${VARDEF_GUID_BOOLEAN}_VariableDefault_${VARDEF_SKUID_BOOLEAN} */\r
${END}\r
  ${SYSTEM_SKU_ID_VALUE}\r
};\r
#endif\r
""")\r
\r
## Mapping between PCD driver type and EFI phase\r
gPcdPhaseMap = {\r
    "PEI_PCD_DRIVER"    :   "PEI",\r
    "DXE_PCD_DRIVER"    :   "DXE"\r
}\r
\r
gPcdDatabaseAutoGenH = TemplateString("""\r
#define PCD_${PHASE}_SERVICE_DRIVER_VERSION         ${SERVICE_DRIVER_VERSION}\r
\r
//\r
// External PCD database debug information\r
//\r
#if 0\r
#define ${PHASE}_GUID_TABLE_SIZE                ${GUID_TABLE_SIZE}\r
#define ${PHASE}_STRING_TABLE_SIZE              ${STRING_TABLE_SIZE}\r
#define ${PHASE}_SKUID_TABLE_SIZE               ${SKUID_TABLE_SIZE}\r
#define ${PHASE}_LOCAL_TOKEN_NUMBER_TABLE_SIZE  ${LOCAL_TOKEN_NUMBER_TABLE_SIZE}\r
#define ${PHASE}_LOCAL_TOKEN_NUMBER             ${LOCAL_TOKEN_NUMBER}\r
#define ${PHASE}_EXMAPPING_TABLE_SIZE           ${EXMAPPING_TABLE_SIZE}\r
#define ${PHASE}_EX_TOKEN_NUMBER                ${EX_TOKEN_NUMBER}\r
#define ${PHASE}_SIZE_TABLE_SIZE                ${SIZE_TABLE_SIZE}\r
#define ${PHASE}_GUID_TABLE_EMPTY               ${GUID_TABLE_EMPTY}\r
#define ${PHASE}_STRING_TABLE_EMPTY             ${STRING_TABLE_EMPTY}\r
#define ${PHASE}_SKUID_TABLE_EMPTY              ${SKUID_TABLE_EMPTY}\r
#define ${PHASE}_DATABASE_EMPTY                 ${DATABASE_EMPTY}\r
#define ${PHASE}_EXMAP_TABLE_EMPTY              ${EXMAP_TABLE_EMPTY}\r
\r
typedef struct {\r
  UINT64             SkuIdTable[${PHASE}_SKUID_TABLE_SIZE];\r
${BEGIN}  UINT64             ${INIT_CNAME_DECL_UINT64}_${INIT_GUID_DECL_UINT64}[${INIT_NUMSKUS_DECL_UINT64}];\r
${END}\r
${BEGIN}  UINT64             ${VARDEF_CNAME_UINT64}_${VARDEF_GUID_UINT64}_VariableDefault_${VARDEF_SKUID_UINT64};\r
${END}\r
${BEGIN}  UINT32             ${INIT_CNAME_DECL_UINT32}_${INIT_GUID_DECL_UINT32}[${INIT_NUMSKUS_DECL_UINT32}];\r
${END}\r
${BEGIN}  UINT32             ${VARDEF_CNAME_UINT32}_${VARDEF_GUID_UINT32}_VariableDefault_${VARDEF_SKUID_UINT32};\r
${END}\r
${BEGIN}  VPD_HEAD           ${VPD_HEAD_CNAME_DECL}_${VPD_HEAD_GUID_DECL}[${VPD_HEAD_NUMSKUS_DECL}];\r
${END}\r
  DYNAMICEX_MAPPING  ExMapTable[${PHASE}_EXMAPPING_TABLE_SIZE];\r
  UINT32             LocalTokenNumberTable[${PHASE}_LOCAL_TOKEN_NUMBER_TABLE_SIZE];\r
  GUID               GuidTable[${PHASE}_GUID_TABLE_SIZE];\r
${BEGIN}  STRING_HEAD        ${STRING_HEAD_CNAME_DECL}_${STRING_HEAD_GUID_DECL}[${STRING_HEAD_NUMSKUS_DECL}];\r
${END}\r
${BEGIN}  VARIABLE_HEAD      ${VARIABLE_HEAD_CNAME_DECL}_${VARIABLE_HEAD_GUID_DECL}_Variable_Header[${VARIABLE_HEAD_NUMSKUS_DECL}];\r
${BEGIN}  UINT8              StringTable${STRING_TABLE_INDEX}[${STRING_TABLE_LENGTH}]; /* ${STRING_TABLE_CNAME}_${STRING_TABLE_GUID} */\r
${END}\r
  SIZE_INFO          SizeTable[${PHASE}_SIZE_TABLE_SIZE];\r
${BEGIN}  UINT16             ${INIT_CNAME_DECL_UINT16}_${INIT_GUID_DECL_UINT16}[${INIT_NUMSKUS_DECL_UINT16}];\r
${END}\r
${BEGIN}  UINT16             ${VARDEF_CNAME_UINT16}_${VARDEF_GUID_UINT16}_VariableDefault_${VARDEF_SKUID_UINT16};\r
${END}\r
${BEGIN}  UINT8              ${INIT_CNAME_DECL_UINT8}_${INIT_GUID_DECL_UINT8}[${INIT_NUMSKUS_DECL_UINT8}];\r
${END}\r
${BEGIN}  UINT8              ${VARDEF_CNAME_UINT8}_${VARDEF_GUID_UINT8}_VariableDefault_${VARDEF_SKUID_UINT8};\r
${END}\r
${BEGIN}  BOOLEAN            ${INIT_CNAME_DECL_BOOLEAN}_${INIT_GUID_DECL_BOOLEAN}[${INIT_NUMSKUS_DECL_BOOLEAN}];\r
${END}\r
${BEGIN}  BOOLEAN            ${VARDEF_CNAME_BOOLEAN}_${VARDEF_GUID_BOOLEAN}_VariableDefault_${VARDEF_SKUID_BOOLEAN};\r
${END}\r
${SYSTEM_SKU_ID}\r
} ${PHASE}_PCD_DATABASE_INIT;\r
\r
typedef struct {\r
${PCD_DATABASE_UNINIT_EMPTY}\r
${BEGIN}  UINT64   ${UNINIT_CNAME_DECL_UINT64}_${UNINIT_GUID_DECL_UINT64}[${UNINIT_NUMSKUS_DECL_UINT64}];\r
${END}\r
${BEGIN}  UINT32   ${UNINIT_CNAME_DECL_UINT32}_${UNINIT_GUID_DECL_UINT32}[${UNINIT_NUMSKUS_DECL_UINT32}];\r
${END}\r
${BEGIN}  UINT16   ${UNINIT_CNAME_DECL_UINT16}_${UNINIT_GUID_DECL_UINT16}[${UNINIT_NUMSKUS_DECL_UINT16}];\r
${END}\r
${BEGIN}  UINT8    ${UNINIT_CNAME_DECL_UINT8}_${UNINIT_GUID_DECL_UINT8}[${UNINIT_NUMSKUS_DECL_UINT8}];\r
${END}\r
${BEGIN}  BOOLEAN  ${UNINIT_CNAME_DECL_BOOLEAN}_${UNINIT_GUID_DECL_BOOLEAN}[${UNINIT_NUMSKUS_DECL_BOOLEAN}];\r
${END}\r
} ${PHASE}_PCD_DATABASE_UNINIT;\r
\r
typedef struct {\r
  //GUID                  Signature;  // PcdDataBaseGuid\r
  //UINT32                BuildVersion;\r
  //UINT32                Length;\r
  //SKU_ID                SystemSkuId;       // Current SkuId value.\r
  //UINT32                LengthForAllSkus;  // Length of all SKU PCD DB\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          StringTableOffset;\r
  //TABLE_OFFSET          SizeTableOffset;\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
  //UINT16                GuidTableCount;   // The Number of Guid in GuidTable\r
  //UINT8                 Pad[6];\r
  ${PHASE}_PCD_DATABASE_INIT    Init;\r
  ${PHASE}_PCD_DATABASE_UNINIT  Uninit;\r
} ${PHASE}_PCD_DATABASE;\r
\r
#define ${PHASE}_NEX_TOKEN_NUMBER (${PHASE}_LOCAL_TOKEN_NUMBER - ${PHASE}_EX_TOKEN_NUMBER)\r
#endif\r
""")\r
\r
\r
gEmptyPcdDatabaseAutoGenC = TemplateString("""\r
//\r
// External PCD database debug information\r
//\r
#if 0\r
${PHASE}_PCD_DATABASE_INIT g${PHASE}PcdDbInit = {\r
  /* SkuIdTable */\r
  { 0 },\r
  /* ExMapTable */\r
  {\r
    {0, 0, 0}\r
  },\r
  /* LocalTokenNumberTable */\r
  {\r
    0\r
  },\r
  /* GuidTable */\r
  {\r
    {0x00000000, 0x0000, 0x0000, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}\r
  },\r
  /* StringTable */\r
  { 0 },\r
  /* SkuHead */\r
  {\r
    0, 0\r
  },\r
  /* SizeTable */\r
  {\r
    0, 0\r
  },\r
  ${SYSTEM_SKU_ID_VALUE}\r
};\r
#endif\r
""")\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
#  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
#  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
#\r
class DbItemList:\r
    def __init__(self, ItemSize, DataList=None, RawDataList=None):\r
        self.ItemSize = ItemSize\r
        self.DataList = DataList if DataList else []\r
        self.RawDataList = RawDataList if RawDataList else []\r
        self.ListSize = 0\r
\r
    def GetInterOffset(self, Index):\r
        Offset = 0\r
        if self.ItemSize == 0:\r
            #\r
            # Variable length, need to calculate one by one\r
            #\r
            assert(Index < len(self.RawDataList))\r
            for ItemIndex in range(Index):\r
                Offset += len(self.RawDataList[ItemIndex])\r
        else:\r
            Offset = self.ItemSize * Index\r
\r
        return Offset\r
\r
    def GetListSize(self):\r
        if self.ListSize:\r
            return self.ListSize\r
        if len(self.RawDataList) == 0:\r
            self.ListSize = 0\r
            return self.ListSize\r
        if self.ItemSize == 0:\r
            self.ListSize = self.GetInterOffset(len(self.RawDataList) - 1) + len(self.RawDataList[len(self.RawDataList)-1])\r
        else:\r
            self.ListSize = self.ItemSize * len(self.RawDataList)\r
        return self.ListSize\r
\r
    def PackData(self):\r
        ## PackGuid\r
        #\r
        # Pack the GUID value in C structure format into data array\r
        #\r
        # @param GuidStructureValue:   The GUID value in C structure format\r
        #\r
        # @retval Buffer:  a data array contains the Guid\r
        #\r
        def PackGuid(GuidStructureValue):\r
            GuidString = GuidStructureStringToGuidString(GuidStructureValue)\r
            return PackGUID(GuidString.split('-'))\r
\r
        PackStr = PACK_CODE_BY_SIZE[self.ItemSize]\r
\r
        Buffer = bytearray()\r
        for Datas in self.RawDataList:\r
            if type(Datas) in (list, tuple):\r
                for Data in Datas:\r
                    if PackStr:\r
                        Buffer += pack(PackStr, GetIntegerValue(Data))\r
                    else:\r
                        Buffer += PackGuid(Data)\r
            else:\r
                if PackStr:\r
                    Buffer += pack(PackStr, GetIntegerValue(Datas))\r
                else:\r
                    Buffer += PackGuid(Datas)\r
\r
        return Buffer\r
\r
## DbExMapTblItemList\r
#\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 = bytearray()\r
        PackStr = "=LHH"\r
        for Datas in self.RawDataList:\r
            Buffer += pack(PackStr,\r
                           GetIntegerValue(Datas[0]),\r
                           GetIntegerValue(Datas[1]),\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
# ItemSize multiply the ItemCount.\r
#\r
class DbComItemList (DbItemList):\r
    def __init__(self, ItemSize, DataList=None, RawDataList=None):\r
        DbItemList.__init__(self, ItemSize, DataList, RawDataList)\r
\r
    def GetInterOffset(self, Index):\r
        Offset = 0\r
        if self.ItemSize == 0:\r
            #\r
            # Variable length, need to calculte 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 range(Index):\r
                Offset += len(self.RawDataList[ItemIndex]) * self.ItemSize\r
\r
        return Offset\r
\r
    def GetListSize(self):\r
        if self.ListSize:\r
            return self.ListSize\r
        if self.ItemSize == 0:\r
            assert(False)\r
        else:\r
            if len(self.RawDataList) == 0:\r
                self.ListSize = 0\r
            else:\r
                self.ListSize = self.GetInterOffset(len(self.RawDataList) - 1) + len(self.RawDataList[len(self.RawDataList)-1]) * self.ItemSize\r
\r
        return self.ListSize\r
\r
    def PackData(self):\r
        PackStr = PACK_CODE_BY_SIZE[self.ItemSize]\r
\r
        Buffer = bytearray()\r
        for DataList in self.RawDataList:\r
            for Data in DataList:\r
                if type(Data) in (list, tuple):\r
                    for SingleData in Data:\r
                        Buffer += pack(PackStr, GetIntegerValue(SingleData))\r
                else:\r
                    Buffer += pack(PackStr, GetIntegerValue(Data))\r
\r
        return Buffer\r
\r
## DbVariableTableItemList\r
#\r
#  The class holds the Variable header value table\r
#\r
class DbVariableTableItemList (DbComItemList):\r
    def __init__(self, ItemSize, DataList=None, RawDataList=None):\r
        DbComItemList.__init__(self, ItemSize, DataList, RawDataList)\r
\r
    def PackData(self):\r
        PackStr = "=LLHHLHH"\r
        Buffer = bytearray()\r
        for DataList in self.RawDataList:\r
            for Data in DataList:\r
                Buffer += pack(PackStr,\r
                               GetIntegerValue(Data[0]),\r
                               GetIntegerValue(Data[1]),\r
                               GetIntegerValue(Data[2]),\r
                               GetIntegerValue(Data[3]),\r
                               GetIntegerValue(Data[4]),\r
                               GetIntegerValue(Data[5]),\r
                               GetIntegerValue(0))\r
        return Buffer\r
\r
class DbStringHeadTableItemList(DbItemList):\r
    def __init__(self,ItemSize,DataList=None,RawDataList=None):\r
        DbItemList.__init__(self, ItemSize, DataList, RawDataList)\r
\r
    def GetInterOffset(self, Index):\r
        Offset = 0\r
        if self.ItemSize == 0:\r
            #\r
            # Variable length, need to calculate one by one\r
            #\r
            assert(Index < len(self.RawDataList))\r
            for ItemIndex in range(Index):\r
                Offset += len(self.RawDataList[ItemIndex])\r
        else:\r
            for innerIndex in range(Index):\r
                if type(self.RawDataList[innerIndex]) in (list, tuple):\r
                    Offset += len(self.RawDataList[innerIndex]) * self.ItemSize\r
                else:\r
                    Offset += self.ItemSize\r
\r
        return Offset\r
\r
    def GetListSize(self):\r
        if self.ListSize:\r
            return self.ListSize\r
        if len(self.RawDataList) == 0:\r
            self.ListSize = 0\r
            return self.ListSize\r
        if self.ItemSize == 0:\r
            self.ListSize = self.GetInterOffset(len(self.RawDataList) - 1) + len(self.RawDataList[len(self.RawDataList)-1])\r
        else:\r
            for Datas in self.RawDataList:\r
                if type(Datas) in (list, tuple):\r
                    self.ListSize += len(Datas) * self.ItemSize\r
                else:\r
                    self.ListSize += self.ItemSize\r
        return self.ListSize\r
\r
## DbSkuHeadTableItemList\r
#\r
#  The class holds the Sku header value table\r
#\r
class DbSkuHeadTableItemList (DbItemList):\r
    def __init__(self, ItemSize, DataList=None, RawDataList=None):\r
        DbItemList.__init__(self, ItemSize, DataList, RawDataList)\r
\r
    def PackData(self):\r
        PackStr = "=LL"\r
        Buffer = bytearray()\r
        for Data in self.RawDataList:\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
#\r
class DbSizeTableItemList (DbItemList):\r
    def __init__(self, ItemSize, DataList=None, RawDataList=None):\r
        DbItemList.__init__(self, ItemSize, DataList, RawDataList)\r
\r
    def GetListSize(self):\r
        length = 0\r
        for Data in self.RawDataList:\r
            length += (1 + len(Data[1]))\r
        return length * self.ItemSize\r
    def PackData(self):\r
        PackStr = "=H"\r
        Buffer = bytearray()\r
        for Data in self.RawDataList:\r
            Buffer += pack(PackStr,\r
                           GetIntegerValue(Data[0]))\r
            for subData in Data[1]:\r
                Buffer += pack(PackStr,\r
                           GetIntegerValue(subData))\r
        return Buffer\r
\r
## DbStringItemList\r
#\r
#  The class holds the string table\r
#\r
class DbStringItemList (DbComItemList):\r
    def __init__(self, ItemSize, DataList=None, RawDataList=None, LenList=None):\r
        if DataList is None:\r
            DataList = []\r
        if RawDataList is None:\r
            RawDataList = []\r
        if LenList is None:\r
            LenList = []\r
\r
        assert(len(RawDataList) == len(LenList))\r
        DataList = []\r
        # adjust DataList according to the LenList\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 range(len(RawDatas)):\r
                ActualDatas.append(RawDatas[i])\r
            for i in range(len(RawDatas), Len):\r
                ActualDatas.append(0)\r
            DataList.append(ActualDatas)\r
        self.LenList = LenList\r
        DbComItemList.__init__(self, ItemSize, DataList, RawDataList)\r
    def GetInterOffset(self, Index):\r
        Offset = 0\r
\r
        assert(Index < len(self.LenList))\r
        for ItemIndex in range(Index):\r
            Offset += self.LenList[ItemIndex]\r
\r
        return Offset\r
\r
    def GetListSize(self):\r
        if self.ListSize:\r
            return self.ListSize\r
\r
        if len(self.LenList) == 0:\r
            self.ListSize = 0\r
        else:\r
            self.ListSize = self.GetInterOffset(len(self.LenList) - 1) + self.LenList[len(self.LenList)-1]\r
\r
        return self.ListSize\r
\r
    def PackData(self):\r
        self.RawDataList = self.DataList\r
        return DbComItemList.PackData(self)\r
\r
\r
\r
##  Find the index in two list where the item matches the key separately\r
#\r
#   @param      Key1   The key used to search the List1\r
#   @param      List1  The list that Key1 will be searched\r
#   @param      Key2   The key used to search the List2\r
#   @param      List2  The list that Key2 will be searched\r
#\r
#   @retval     Index  The position inside the list where list1[Index] == Key1 and list2[Index] == Key2\r
#\r
def GetMatchedIndex(Key1, List1, Key2, List2):\r
    StartPos = 0\r
    while StartPos < len(List1):\r
        Index = List1.index(Key1, StartPos)\r
        if List2[Index] == Key2:\r
            return Index\r
        else:\r
            StartPos = Index + 1\r
\r
    return -1\r
\r
\r
## convert StringArray like {0x36, 0x00, 0x34, 0x00, 0x21, 0x00, 0x36, 0x00, 0x34, 0x00, 0x00, 0x00}\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
#   @retval                 A list object of integer items\r
#\r
def StringArrayToList(StringArray):\r
    StringArray = StringArray[1:-1]\r
    StringArray = '[' + StringArray + ']'\r
    return eval(StringArray)\r
\r
\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
#   @retval                A integer representation of the TokenType\r
#\r
def GetTokenTypeValue(TokenType):\r
    TokenTypeDict = {\r
        "PCD_TYPE_SHIFT": 28,\r
        "PCD_TYPE_DATA": (0x0 << 28),\r
        "PCD_TYPE_HII": (0x8 << 28),\r
        "PCD_TYPE_VPD": (0x4 << 28),\r
#        "PCD_TYPE_SKU_ENABLED":(0x2 << 28),\r
        "PCD_TYPE_STRING": (0x1 << 28),\r
\r
        "PCD_DATUM_TYPE_SHIFT": 24,\r
        "PCD_DATUM_TYPE_POINTER": (0x0 << 24),\r
        "PCD_DATUM_TYPE_UINT8": (0x1 << 24),\r
        "PCD_DATUM_TYPE_UINT16": (0x2 << 24),\r
        "PCD_DATUM_TYPE_UINT32": (0x4 << 24),\r
        "PCD_DATUM_TYPE_UINT64": (0x8 << 24),\r
\r
        "PCD_DATUM_TYPE_SHIFT2": 20,\r
        "PCD_DATUM_TYPE_UINT8_BOOLEAN": (0x1 << 20 | 0x1 << 24),\r
        }\r
    return eval(TokenType, TokenTypeDict)\r
\r
## construct the external Pcd database using data from Dict\r
#\r
#   @param      Dict  A dictionary contains Pcd related tables\r
#\r
#   @retval     Buffer A byte stream of the Pcd database\r
#\r
def BuildExDataBase(Dict):\r
    # init Db items\r
    InitValueUint64 = Dict['INIT_DB_VALUE_UINT64']\r
    DbInitValueUint64 = DbComItemList(8, RawDataList = InitValueUint64)\r
    VardefValueUint64 = Dict['VARDEF_DB_VALUE_UINT64']\r
    DbVardefValueUint64 = DbItemList(8, RawDataList = VardefValueUint64)\r
    InitValueUint32 = Dict['INIT_DB_VALUE_UINT32']\r
    DbInitValueUint32 = DbComItemList(4, RawDataList = InitValueUint32)\r
    VardefValueUint32 = Dict['VARDEF_DB_VALUE_UINT32']\r
    DbVardefValueUint32 = DbItemList(4, RawDataList = VardefValueUint32)\r
    VpdHeadValue = Dict['VPD_DB_VALUE']\r
    DbVpdHeadValue = DbComItemList(4, RawDataList = VpdHeadValue)\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
    GuidTable = Dict['GUID_STRUCTURE']\r
    DbGuidTable = DbItemList(16, RawDataList = GuidTable)\r
    StringHeadValue = Dict['STRING_DB_VALUE']\r
    # DbItemList to DbStringHeadTableItemList\r
    DbStringHeadValue = DbStringHeadTableItemList(4, RawDataList = StringHeadValue)\r
    VariableTable = Dict['VARIABLE_DB_VALUE']\r
    DbVariableTable = DbVariableTableItemList(20, RawDataList = VariableTable)\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
    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
    StringTableLen = Dict['STRING_TABLE_LENGTH']\r
    DbStringTableLen = DbStringItemList(0, RawDataList = StringTableValue, LenList = StringTableLen)\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
    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
    PcdNameOffsetTable = Dict['PCD_NAME_OFFSET']\r
    DbPcdNameOffsetTable = DbItemList(4, RawDataList = PcdNameOffsetTable)\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
    VardefValueUint16 = Dict['VARDEF_DB_VALUE_UINT16']\r
    DbVardefValueUint16 = DbItemList(2, RawDataList = VardefValueUint16)\r
    InitValueUint8 = Dict['INIT_DB_VALUE_UINT8']\r
    DbInitValueUint8 = DbComItemList(1, RawDataList = InitValueUint8)\r
    VardefValueUint8 = Dict['VARDEF_DB_VALUE_UINT8']\r
    DbVardefValueUint8 = DbItemList(1, RawDataList = VardefValueUint8)\r
    InitValueBoolean = Dict['INIT_DB_VALUE_BOOLEAN']\r
    DbInitValueBoolean = DbComItemList(1, RawDataList = InitValueBoolean)\r
    VardefValueBoolean = Dict['VARDEF_DB_VALUE_BOOLEAN']\r
    DbVardefValueBoolean = DbItemList(1, RawDataList = VardefValueBoolean)\r
    SkuidValue = Dict['SKUID_VALUE']\r
    DbSkuidValue = DbItemList(8, RawDataList = SkuidValue)\r
\r
\r
\r
    # Unit Db Items\r
    UnInitValueUint64 = Dict['UNINIT_GUID_DECL_UINT64']\r
    DbUnInitValueUint64 = DbItemList(8, RawDataList = UnInitValueUint64)\r
    UnInitValueUint32 = Dict['UNINIT_GUID_DECL_UINT32']\r
    DbUnInitValueUint32 = DbItemList(4, RawDataList = UnInitValueUint32)\r
    UnInitValueUint16 = Dict['UNINIT_GUID_DECL_UINT16']\r
    DbUnInitValueUint16 = DbItemList(2, RawDataList = UnInitValueUint16)\r
    UnInitValueUint8 = Dict['UNINIT_GUID_DECL_UINT8']\r
    DbUnInitValueUint8 = DbItemList(1, RawDataList = UnInitValueUint8)\r
    UnInitValueBoolean = Dict['UNINIT_GUID_DECL_BOOLEAN']\r
    DbUnInitValueBoolean = DbItemList(1, RawDataList = UnInitValueBoolean)\r
    PcdTokenNumberMap = Dict['PCD_ORDER_TOKEN_NUMBER_MAP']\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
    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
               VardefValueBoolean, UnInitValueUint64, UnInitValueUint32, UnInitValueUint16, UnInitValueUint8, UnInitValueBoolean]\r
    DbItemTotal = [DbSkuidValue,  DbInitValueUint64, DbVardefValueUint64, DbInitValueUint32, DbVardefValueUint32, DbVpdHeadValue, DbExMapTable,\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
    # 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
    SkuIdTableOffset = FixedHeaderLen\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
    # Fix up the LocalTokenNumberTable, SkuHeader table\r
    for (LocalTokenNumberTableIndex, (Offset, Table)) in enumerate(LocalTokenNumberTable):\r
        DbIndex = 0\r
        DbOffset = FixedHeaderLen\r
        for DbIndex in range(len(DbTotal)):\r
            if DbTotal[DbIndex] is Table:\r
                DbOffset += DbItemTotal[DbIndex].GetInterOffset(Offset)\r
                break\r
            DbOffset += DbItemTotal[DbIndex].GetListSize()\r
            if DbIndex + 1 == InitTableNum:\r
                if DbOffset % 8:\r
                    DbOffset += (8 - DbOffset % 8)\r
        else:\r
            assert(False)\r
\r
        TokenTypeValue = Dict['TOKEN_TYPE'][LocalTokenNumberTableIndex]\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
    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 range(len(DbTotal)):\r
                if DbTotal[DbIndex] is VariableRefTable:\r
                    DbOffset += DbItemTotal[DbIndex].GetInterOffset(VariableOffset)\r
                    break\r
                DbOffset += DbItemTotal[DbIndex].GetListSize()\r
                if DbIndex + 1 == InitTableNum:\r
                    if DbOffset % 8:\r
                        DbOffset += (8 - DbOffset % 8)\r
            else:\r
                assert(False)\r
            if isinstance(VariableRefTable[0], list):\r
                DbOffset += skuindex * 4\r
            skuindex += 1\r
            if DbIndex >= InitTableNum:\r
                assert(False)\r
            VarAttr, VarProp = VariableAttributes.GetVarAttributes(VariableAttribute)\r
            VariableEntryPerSku[:] = (VariableHeadStringIndex, DbOffset, VariableHeadGuidIndex, SKUVariableOffset, VarAttr, VarProp)\r
\r
    # calculate various table offset now\r
    DbTotalLength = FixedHeaderLen\r
    for DbIndex in range(len(DbItemTotal)):\r
        if DbItemTotal[DbIndex] is DbLocalTokenNumberTable:\r
            LocalTokenNumberTableOffset = DbTotalLength\r
        elif DbItemTotal[DbIndex] is DbExMapTable:\r
            ExMapTableOffset = DbTotalLength\r
        elif DbItemTotal[DbIndex] is DbGuidTable:\r
            GuidTableOffset = DbTotalLength\r
        elif DbItemTotal[DbIndex] is DbStringTableLen:\r
            StringTableOffset = DbTotalLength\r
        elif DbItemTotal[DbIndex] is DbSizeTableValue:\r
            SizeTableOffset = DbTotalLength\r
        elif DbItemTotal[DbIndex] is DbSkuidValue:\r
            SkuIdTableOffset = DbTotalLength\r
        elif DbItemTotal[DbIndex] is DbPcdNameOffsetTable:\r
            DbPcdNameOffset = DbTotalLength\r
\r
\r
        DbTotalLength += DbItemTotal[DbIndex].GetListSize()\r
    if not Dict['PCD_INFO_FLAG']:\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
    UninitDataBaseSize  = 0\r
    for Item in (DbUnInitValueUint64, DbUnInitValueUint32, DbUnInitValueUint16, DbUnInitValueUint8, DbUnInitValueBoolean):\r
        UninitDataBaseSize += Item.GetListSize()\r
\r
    if (DbTotalLength - UninitDataBaseSize) % 8:\r
        DbTotalLength += (8 - (DbTotalLength - UninitDataBaseSize) % 8)\r
    # Construct the database buffer\r
    Guid = "{0x3c7d193c, 0x682c, 0x4c14, 0xa6, 0x8f, 0x55, 0x2d, 0xea, 0x4f, 0x43, 0x7e}"\r
    Guid = StringArrayToList(Guid)\r
    Buffer = PackByteFormatGUID(Guid)\r
\r
    b = pack("=L", DATABASE_VERSION)\r
    Buffer += b\r
\r
    b = pack('=L', DbTotalLength - UninitDataBaseSize)\r
\r
    Buffer += b\r
    b = pack('=Q', SystemSkuId)\r
\r
    Buffer += b\r
    b = pack('=L', 0)\r
\r
    Buffer += b\r
    b = pack('=L', UninitDataBaseSize)\r
\r
    Buffer += b\r
    b = pack('=L', LocalTokenNumberTableOffset)\r
\r
    Buffer += b\r
    b = pack('=L', ExMapTableOffset)\r
\r
    Buffer += b\r
    b = pack('=L', GuidTableOffset)\r
\r
    Buffer += b\r
    b = pack('=L', StringTableOffset)\r
\r
    Buffer += b\r
    b = pack('=L', SizeTableOffset)\r
\r
    Buffer += b\r
    b = pack('=L', SkuIdTableOffset)\r
\r
    Buffer += b\r
    b = pack('=L', DbPcdNameOffset)\r
\r
    Buffer += b\r
    b = pack('=H', LocalTokenCount)\r
\r
    Buffer += b\r
    b = pack('=H', ExTokenCount)\r
\r
    Buffer += b\r
    b = pack('=H', GuidTableCount)\r
\r
    Buffer += b\r
    b = pack('=B', Pad)\r
    Buffer += b\r
    Buffer += b\r
    Buffer += b\r
    Buffer += b\r
    Buffer += b\r
    Buffer += b\r
\r
    Index = 0\r
    for Item in DbItemTotal:\r
        Index +=1\r
        b = bytes(Item.PackData())\r
        Buffer += b\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
    return Buffer\r
\r
## Create code for PCD database\r
#\r
#   @param      Info        The ModuleAutoGen object\r
#   @param      AutoGenC    The TemplateString object for C code\r
#   @param      AutoGenH    The TemplateString object for header file\r
#\r
def CreatePcdDatabaseCode (Info, AutoGenC, AutoGenH):\r
    if Info.PcdIsDriver == "":\r
        return\r
    if Info.PcdIsDriver not in gPcdPhaseMap:\r
        EdkLogger.error("build", AUTOGEN_ERROR, "Not supported PcdIsDriver type:%s" % Info.PcdIsDriver,\r
                        ExtraData="[%s]" % str(Info))\r
\r
    AdditionalAutoGenH, AdditionalAutoGenC, PcdDbBuffer = NewCreatePcdDatabasePhaseSpecificAutoGen (Info.PlatformInfo, 'PEI')\r
    AutoGenH.Append(AdditionalAutoGenH.String)\r
\r
    Phase = gPcdPhaseMap[Info.PcdIsDriver]\r
    if Phase == 'PEI':\r
        AutoGenC.Append(AdditionalAutoGenC.String)\r
\r
    if Phase == 'DXE':\r
        AdditionalAutoGenH, AdditionalAutoGenC, PcdDbBuffer = NewCreatePcdDatabasePhaseSpecificAutoGen (Info.PlatformInfo, Phase)\r
        AutoGenH.Append(AdditionalAutoGenH.String)\r
        AutoGenC.Append(AdditionalAutoGenC.String)\r
\r
    if Info.IsBinaryModule:\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 = BytesIO()\r
    DbFile.write(PcdDbBuffer)\r
    Changed = SaveFileOnChange(DbFileName, DbFile.getvalue(), True)\r
def CreatePcdDataBase(PcdDBData):\r
    delta = {}\r
    for skuname, skuid in PcdDBData:\r
        if len(PcdDBData[(skuname, skuid)][1]) != len(PcdDBData[(TAB_DEFAULT, "0")][1]):\r
            EdkLogger.ERROR("The size of each sku in one pcd are not same")\r
    for skuname, skuid in PcdDBData:\r
        if skuname == TAB_DEFAULT:\r
            continue\r
        delta[(skuname, skuid)] = [(index, data, hex(data)) for index, data in enumerate(PcdDBData[(skuname, skuid)][1]) if PcdDBData[(skuname, skuid)][1][index] != PcdDBData[(TAB_DEFAULT, "0")][1][index]]\r
    databasebuff = PcdDBData[(TAB_DEFAULT, "0")][0]\r
\r
    for skuname, skuid in delta:\r
        # 8 byte align\r
        if len(databasebuff) % 8 > 0:\r
            for i in range(8 - (len(databasebuff) % 8)):\r
                databasebuff += pack("=B", 0)\r
        databasebuff += pack('=Q', int(skuid))\r
        databasebuff += pack('=Q', 0)\r
        databasebuff += pack('=L', 8+8+4+4*len(delta[(skuname, skuid)]))\r
        for item in delta[(skuname, skuid)]:\r
            databasebuff += pack("=L", item[0])\r
            databasebuff = databasebuff[:-1] + pack("=B", item[1])\r
    totallen = len(databasebuff)\r
    totallenbuff = pack("=L", totallen)\r
    newbuffer = databasebuff[:32]\r
    for i in range(4):\r
        newbuffer += bytes([totallenbuff[i]])\r
    for i in range(36, totallen):\r
        newbuffer += bytes([databasebuff[i]])\r
\r
    return newbuffer\r
\r
def CreateVarCheckBin(VarCheckTab):\r
    return VarCheckTab[(TAB_DEFAULT, "0")]\r
\r
def CreateAutoGen(PcdDriverAutoGenData):\r
    autogenC = TemplateString()\r
    for skuname, skuid in PcdDriverAutoGenData:\r
        autogenC.Append("//SKUID: %s" % skuname)\r
        autogenC.Append(PcdDriverAutoGenData[(skuname, skuid)][1].String)\r
    return (PcdDriverAutoGenData[(skuname, skuid)][0], autogenC)\r
def NewCreatePcdDatabasePhaseSpecificAutoGen(Platform, Phase):\r
    def prune_sku(pcd, skuname):\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_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
                    if defaultvalue  != 0:\r
                        new_pcd.isinit = "INIT"\r
                        break\r
                elif skuobj.VariableName:\r
                    new_pcd.isinit = "INIT"\r
                    break\r
            else:\r
                new_pcd.isinit = "UNINIT"\r
        return new_pcd\r
    DynamicPcds = Platform.DynamicPcdList\r
    DynamicPcdSet_Sku = {(SkuName, skuobj.SkuId):[] for pcd in DynamicPcds for (SkuName, skuobj) in pcd.SkuInfoList.items() }\r
    for skuname, skuid in DynamicPcdSet_Sku:\r
        DynamicPcdSet_Sku[(skuname, skuid)] = [prune_sku(pcd, skuname) for pcd in DynamicPcds]\r
    PcdDBData = {}\r
    PcdDriverAutoGenData = {}\r
    VarCheckTableData = {}\r
    if DynamicPcdSet_Sku:\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", bytes([item]))\r
            PcdDBData[(skuname, skuid)] = (PcdDbBuffer, final_data)\r
            PcdDriverAutoGenData[(skuname, skuid)] = (AdditionalAutoGenH, AdditionalAutoGenC)\r
            VarCheckTableData[(skuname, skuid)] = VarCheckTab\r
        if Platform.Platform.VarCheckFlag:\r
            dest = os.path.join(Platform.BuildDir, TAB_FV_DIRECTORY)\r
            VarCheckTable = CreateVarCheckBin(VarCheckTableData)\r
            VarCheckTable.dump(dest, Phase)\r
        AdditionalAutoGenH, AdditionalAutoGenC =  CreateAutoGen(PcdDriverAutoGenData)\r
    else:\r
        AdditionalAutoGenH, AdditionalAutoGenC, PcdDbBuffer, VarCheckTab = CreatePcdDatabasePhaseSpecificAutoGen (Platform, {}, Phase)\r
        final_data = ()\r
        for item in PcdDbBuffer:\r
            final_data += unpack("B", bytes([item]))\r
        PcdDBData[(TAB_DEFAULT, "0")] = (PcdDbBuffer, final_data)\r
\r
    return AdditionalAutoGenH, AdditionalAutoGenC, CreatePcdDataBase(PcdDBData)\r
## Create PCD database in DXE or PEI phase\r
#\r
#   @param      Platform    The platform object\r
#   @retval     tuple       Two TemplateString objects for C code and header file,\r
#                           respectively\r
#\r
def CreatePcdDatabasePhaseSpecificAutoGen (Platform, DynamicPcdList, Phase):\r
    AutoGenC = TemplateString()\r
    AutoGenH = TemplateString()\r
\r
    Dict = {\r
        'PHASE'                         : Phase,\r
        'SERVICE_DRIVER_VERSION'        : DATABASE_VERSION,\r
        'GUID_TABLE_SIZE'               : '1U',\r
        'STRING_TABLE_SIZE'             : '1U',\r
        'SKUID_TABLE_SIZE'              : '1U',\r
        'LOCAL_TOKEN_NUMBER_TABLE_SIZE' : '0U',\r
        'LOCAL_TOKEN_NUMBER'            : '0U',\r
        'EXMAPPING_TABLE_SIZE'          : '1U',\r
        'EX_TOKEN_NUMBER'               : '0U',\r
        'SIZE_TABLE_SIZE'               : '2U',\r
        'SKU_HEAD_SIZE'                 : '1U',\r
        'GUID_TABLE_EMPTY'              : 'TRUE',\r
        'STRING_TABLE_EMPTY'            : 'TRUE',\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
        'SYSTEM_SKU_ID'                 : '  SKU_ID             SystemSkuId;',\r
        'SYSTEM_SKU_ID_VALUE'           : '0U'\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['PCD_INFO_FLAG'] = Platform.Platform.PcdInfoFlag\r
\r
    for DatumType in TAB_PCD_NUMERIC_TYPES_VOID:\r
        Dict['VARDEF_CNAME_' + DatumType] = []\r
        Dict['VARDEF_GUID_' + DatumType]  = []\r
        Dict['VARDEF_SKUID_' + DatumType] = []\r
        Dict['VARDEF_VALUE_' + DatumType] = []\r
        Dict['VARDEF_DB_VALUE_' + DatumType] = []\r
        for Init in ['INIT', 'UNINIT']:\r
            Dict[Init+'_CNAME_DECL_' + DatumType]   = []\r
            Dict[Init+'_GUID_DECL_' + DatumType]    = []\r
            Dict[Init+'_NUMSKUS_DECL_' + DatumType] = []\r
            Dict[Init+'_VALUE_' + DatumType]        = []\r
            Dict[Init+'_DB_VALUE_'+DatumType] = []\r
\r
    for Type in ['STRING_HEAD', 'VPD_HEAD', 'VARIABLE_HEAD']:\r
        Dict[Type + '_CNAME_DECL']   = []\r
        Dict[Type + '_GUID_DECL']    = []\r
        Dict[Type + '_NUMSKUS_DECL'] = []\r
        Dict[Type + '_VALUE'] = []\r
\r
    Dict['STRING_DB_VALUE'] = []\r
    Dict['VPD_DB_VALUE'] = []\r
    Dict['VARIABLE_DB_VALUE'] = []\r
\r
    Dict['STRING_TABLE_INDEX'] = []\r
    Dict['STRING_TABLE_LENGTH']  = []\r
    Dict['STRING_TABLE_CNAME'] = []\r
    Dict['STRING_TABLE_GUID']  = []\r
    Dict['STRING_TABLE_VALUE'] = []\r
    Dict['STRING_TABLE_DB_VALUE'] = []\r
\r
    Dict['SIZE_TABLE_CNAME'] = []\r
    Dict['SIZE_TABLE_GUID']  = []\r
    Dict['SIZE_TABLE_CURRENT_LENGTH']  = []\r
    Dict['SIZE_TABLE_MAXIMUM_LENGTH']  = []\r
\r
    Dict['EXMAPPING_TABLE_EXTOKEN'] = []\r
    Dict['EXMAPPING_TABLE_LOCAL_TOKEN'] = []\r
    Dict['EXMAPPING_TABLE_GUID_INDEX'] = []\r
\r
    Dict['GUID_STRUCTURE'] = []\r
    Dict['SKUID_VALUE'] = [0] # init Dict length\r
    Dict['VARDEF_HEADER'] = []\r
\r
    Dict['LOCAL_TOKEN_NUMBER_DB_VALUE'] = []\r
    Dict['VARIABLE_DB_VALUE'] = []\r
\r
    Dict['PCD_TOKENSPACE'] = []\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
    Dict['PCD_ORDER_TOKEN_NUMBER_MAP'] = {}\r
    PCD_STRING_INDEX_MAP = {}\r
\r
    StringTableIndex = 0\r
    StringTableSize = 0\r
    NumberOfLocalTokens = 0\r
    NumberOfPeiLocalTokens = 0\r
    NumberOfDxeLocalTokens = 0\r
    NumberOfExTokens = 0\r
    NumberOfSizeItems = 0\r
    NumberOfSkuEnabledPcd = 0\r
    GuidList = []\r
    VarCheckTab = VAR_CHECK_PCD_VARIABLE_TAB_CONTAINER()\r
    i = 0\r
    ReorderedDynPcdList = GetOrderedDynamicPcdList(DynamicPcdList, Platform.PcdTokenNumber)\r
    for item in ReorderedDynPcdList:\r
        if item.DatumType not in [TAB_UINT8, TAB_UINT16, TAB_UINT32, TAB_UINT64, TAB_VOID, "BOOLEAN"]:\r
            item.DatumType = TAB_VOID\r
    for Pcd in ReorderedDynPcdList:\r
        VoidStarTypeCurrSize = []\r
        i += 1\r
        CName = Pcd.TokenCName\r
        TokenSpaceGuidCName = Pcd.TokenSpaceGuidCName\r
\r
        for PcdItem in GlobalData.MixedPcd:\r
            if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) in GlobalData.MixedPcd[PcdItem]:\r
                CName = PcdItem[0]\r
\r
        EdkLogger.debug(EdkLogger.DEBUG_3, "PCD: %s %s (%s : %s)" % (CName, TokenSpaceGuidCName, Pcd.Phase, Phase))\r
\r
        if Pcd.Phase == 'PEI':\r
            NumberOfPeiLocalTokens += 1\r
        if Pcd.Phase == 'DXE':\r
            NumberOfDxeLocalTokens += 1\r
        if Pcd.Phase != Phase:\r
            continue\r
\r
        #\r
        # TODO: need GetGuidValue() definition\r
        #\r
        TokenSpaceGuidStructure = Pcd.TokenSpaceGuidValue\r
        TokenSpaceGuid = GuidStructureStringToGuidValueName(TokenSpaceGuidStructure)\r
        if Pcd.Type in PCD_DYNAMIC_EX_TYPE_SET:\r
            if TokenSpaceGuid not in GuidList:\r
                GuidList.append(TokenSpaceGuid)\r
                Dict['GUID_STRUCTURE'].append(TokenSpaceGuidStructure)\r
            NumberOfExTokens += 1\r
\r
        ValueList = []\r
        DbValueList = []\r
        StringHeadOffsetList = []\r
        StringDbOffsetList = []\r
        VpdHeadOffsetList = []\r
        VpdDbOffsetList = []\r
        VariableHeadValueList = []\r
        VariableDbValueList = []\r
        Pcd.InitString = 'UNINIT'\r
\r
        if Pcd.DatumType == TAB_VOID:\r
            if Pcd.Type not in [TAB_PCDS_DYNAMIC_VPD, TAB_PCDS_DYNAMIC_EX_VPD]:\r
                Pcd.TokenTypeList = ['PCD_TYPE_STRING']\r
            else:\r
                Pcd.TokenTypeList = []\r
        elif Pcd.DatumType == 'BOOLEAN':\r
            Pcd.TokenTypeList = ['PCD_DATUM_TYPE_UINT8_BOOLEAN']\r
        else:\r
            Pcd.TokenTypeList = ['PCD_DATUM_TYPE_' + Pcd.DatumType]\r
\r
        if len(Pcd.SkuInfoList) > 1:\r
            NumberOfSkuEnabledPcd += 1\r
\r
        SkuIdIndex = 1\r
        VariableHeadList = []\r
        for SkuName in Pcd.SkuInfoList:\r
            Sku = Pcd.SkuInfoList[SkuName]\r
            SkuId = Sku.SkuId\r
            if SkuId is None or SkuId == '':\r
                continue\r
\r
\r
            SkuIdIndex += 1\r
\r
            if len(Sku.VariableName) > 0:\r
                VariableGuidStructure = Sku.VariableGuidValue\r
                VariableGuid = GuidStructureStringToGuidValueName(VariableGuidStructure)\r
                if Platform.Platform.VarCheckFlag:\r
                    var_check_obj = VAR_CHECK_PCD_VARIABLE_TAB(VariableGuidStructure, StringToArray(Sku.VariableName))\r
                    try:\r
                        var_check_obj.push_back(GetValidationObject(Pcd, Sku.VariableOffset))\r
                        VarAttr, _ = VariableAttributes.GetVarAttributes(Sku.VariableAttribute)\r
                        var_check_obj.SetAttributes(VarAttr)\r
                        var_check_obj.UpdateSize()\r
                        VarCheckTab.push_back(var_check_obj)\r
                    except Exception:\r
                        ValidInfo = ''\r
                        if Pcd.validateranges:\r
                            ValidInfo = Pcd.validateranges[0]\r
                        if Pcd.validlists:\r
                            ValidInfo = Pcd.validlists[0]\r
                        if ValidInfo:\r
                            EdkLogger.error("build", PCD_VALIDATION_INFO_ERROR,\r
                                                "The PCD '%s.%s' Validation information defined in DEC file has incorrect format." % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName),\r
                                                ExtraData = "[%s]" % str(ValidInfo))\r
                        else:\r
                            EdkLogger.error("build", PCD_VALIDATION_INFO_ERROR,\r
                                                "The PCD '%s.%s' Validation information defined in DEC file has incorrect format." % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName))\r
                Pcd.TokenTypeList.append('PCD_TYPE_HII')\r
                Pcd.InitString = 'INIT'\r
                # Store all variable names of one HII PCD under different SKU to stringTable\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
                    if StringTableIndex == 0:\r
                        Dict['STRING_TABLE_INDEX'].append('')\r
                    else:\r
                        Dict['STRING_TABLE_INDEX'].append('_%d' % StringTableIndex)\r
                    VarNameSize = len(VariableNameStructure.replace(',', ' ').split())\r
                    Dict['STRING_TABLE_LENGTH'].append(VarNameSize )\r
                    Dict['STRING_TABLE_VALUE'].append(VariableNameStructure)\r
                    StringHeadOffsetList.append(str(StringTableSize) + 'U')\r
                    VarStringDbOffsetList = []\r
                    VarStringDbOffsetList.append(StringTableSize)\r
                    Dict['STRING_DB_VALUE'].append(VarStringDbOffsetList)\r
                    StringTableIndex += 1\r
                    StringTableSize += len(VariableNameStructure.replace(',', ' ').split())\r
                VariableHeadStringIndex = 0\r
                for Index in range(Dict['STRING_TABLE_VALUE'].index(VariableNameStructure)):\r
                    VariableHeadStringIndex += Dict['STRING_TABLE_LENGTH'][Index]\r
                VariableHeadList.append(VariableHeadStringIndex)\r
\r
                VariableHeadStringIndex = VariableHeadList[SkuIdIndex - 2]\r
                # store VariableGuid to GuidTable and get the VariableHeadGuidIndex\r
\r
                if VariableGuid not in GuidList:\r
                    GuidList.append(VariableGuid)\r
                    Dict['GUID_STRUCTURE'].append(VariableGuidStructure)\r
                VariableHeadGuidIndex = GuidList.index(VariableGuid)\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
                                                 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
                                                 VariableHeadGuidIndex, Sku.VariableOffset))\r
                Dict['VARDEF_CNAME_'+Pcd.DatumType].append(CName)\r
                Dict['VARDEF_GUID_'+Pcd.DatumType].append(TokenSpaceGuid)\r
                Dict['VARDEF_SKUID_'+Pcd.DatumType].append(SkuIdIndex)\r
                if "PCD_TYPE_STRING" in  Pcd.TokenTypeList:\r
                    Dict['VARDEF_VALUE_' + Pcd.DatumType].append("%s_%s[%d]" % (Pcd.TokenCName, TokenSpaceGuid, SkuIdIndex))\r
                else:\r
                    #\r
                    # ULL (for UINT64) or U(other integer type) should be append to avoid\r
                    # warning under linux building environment.\r
                    #\r
                    Dict['VARDEF_DB_VALUE_'+Pcd.DatumType].append(Sku.HiiDefaultValue)\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
                        Dict['VARDEF_VALUE_'+Pcd.DatumType].append(Sku.HiiDefaultValue + "U")\r
                    elif Pcd.DatumType == "BOOLEAN":\r
                        if eval(Sku.HiiDefaultValue) in [1, 0]:\r
                            Dict['VARDEF_VALUE_'+Pcd.DatumType].append(str(eval(Sku.HiiDefaultValue)) + "U")\r
                    else:\r
                        Dict['VARDEF_VALUE_'+Pcd.DatumType].append(Sku.HiiDefaultValue)\r
\r
                # construct the VariableHeader value\r
                if "PCD_TYPE_STRING" in Pcd.TokenTypeList:\r
                    VariableHeadValueList.append('%dU, %dU, %sU, offsetof(%s_PCD_DATABASE, Init.%s_%s)' %\r
                                                 (VariableHeadGuidIndex, VariableHeadStringIndex, Sku.VariableOffset,\r
                                                  Phase, CName, TokenSpaceGuid))\r
                    # the Pcd default value will be filled later on\r
                    VariableOffset = len(Dict['STRING_DB_VALUE'])\r
                    VariableRefTable = Dict['STRING_DB_VALUE']\r
                else:\r
                    VariableHeadValueList.append('%dU, %dU, %sU, offsetof(%s_PCD_DATABASE, Init.%s_%s_VariableDefault_%s)' %\r
                                                 (VariableHeadGuidIndex, VariableHeadStringIndex, Sku.VariableOffset,\r
                                                  Phase, CName, TokenSpaceGuid, SkuIdIndex))\r
                    # the Pcd default value was filled before\r
                    VariableOffset = len(Dict['VARDEF_DB_VALUE_' + Pcd.DatumType]) - 1\r
                    VariableRefTable = Dict['VARDEF_DB_VALUE_' + Pcd.DatumType]\r
                VariableDbValueList.append([VariableHeadGuidIndex, VariableHeadStringIndex, Sku.VariableOffset, VariableOffset, VariableRefTable, Sku.VariableAttribute])\r
\r
            elif Sku.VpdOffset != '':\r
                Pcd.TokenTypeList.append('PCD_TYPE_VPD')\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
                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
                continue\r
\r
            if Pcd.DatumType == TAB_VOID:\r
                Pcd.TokenTypeList.append('PCD_TYPE_STRING')\r
                Pcd.InitString = 'INIT'\r
                if Sku.HiiDefaultValue != '' and Sku.DefaultValue == '':\r
                    Sku.DefaultValue = Sku.HiiDefaultValue\r
                if Sku.DefaultValue != '':\r
                    NumberOfSizeItems += 1\r
                    Dict['STRING_TABLE_CNAME'].append(CName)\r
                    Dict['STRING_TABLE_GUID'].append(TokenSpaceGuid)\r
\r
                    if StringTableIndex == 0:\r
                        Dict['STRING_TABLE_INDEX'].append('')\r
                    else:\r
                        Dict['STRING_TABLE_INDEX'].append('_%d' % StringTableIndex)\r
                    if Sku.DefaultValue[0] == 'L':\r
                        DefaultValueBinStructure = StringToArray(Sku.DefaultValue)\r
                        Size = len(DefaultValueBinStructure.replace(',', ' ').split())\r
                        Dict['STRING_TABLE_VALUE'].append(DefaultValueBinStructure)\r
                    elif Sku.DefaultValue[0] == '"':\r
                        DefaultValueBinStructure = StringToArray(Sku.DefaultValue)\r
                        Size = len(Sku.DefaultValue) - 2 + 1\r
                        Dict['STRING_TABLE_VALUE'].append(DefaultValueBinStructure)\r
                    elif Sku.DefaultValue[0] == '{':\r
                        DefaultValueBinStructure = StringToArray(Sku.DefaultValue)\r
                        Size = len(Sku.DefaultValue.split(","))\r
                        Dict['STRING_TABLE_VALUE'].append(DefaultValueBinStructure)\r
\r
                    StringHeadOffsetList.append(str(StringTableSize) + 'U')\r
                    StringDbOffsetList.append(StringTableSize)\r
                    if Pcd.MaxDatumSize != '':\r
                        MaxDatumSize = int(Pcd.MaxDatumSize, 0)\r
                        if MaxDatumSize < Size:\r
                            if Pcd.MaxSizeUserSet:\r
                                EdkLogger.error("build", AUTOGEN_ERROR,\r
                                            "The maximum size of VOID* type PCD '%s.%s' is less than its actual size occupied." % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName),\r
                                            ExtraData="[%s]" % str(Platform))\r
                            else:\r
                                MaxDatumSize = Size\r
                    else:\r
                        MaxDatumSize = Size\r
                    StringTabLen = MaxDatumSize\r
                    if StringTabLen % 2:\r
                        StringTabLen += 1\r
                    if Sku.VpdOffset == '':\r
                        VoidStarTypeCurrSize.append(str(Size) + 'U')\r
                    Dict['STRING_TABLE_LENGTH'].append(StringTabLen)\r
                    StringTableIndex += 1\r
                    StringTableSize += (StringTabLen)\r
            else:\r
                if "PCD_TYPE_HII" not in Pcd.TokenTypeList:\r
                    Pcd.TokenTypeList.append('PCD_TYPE_DATA')\r
                    if Sku.DefaultValue == 'TRUE':\r
                        Pcd.InitString = 'INIT'\r
                    else:\r
                        Pcd.InitString = Pcd.isinit\r
                #\r
                # For UNIT64 type PCD's value, ULL should be append to avoid\r
                # warning under linux building environment.\r
                #\r
                if Pcd.DatumType == TAB_UINT64:\r
                    ValueList.append(Sku.DefaultValue + "ULL")\r
                elif Pcd.DatumType in (TAB_UINT32, TAB_UINT16, TAB_UINT8):\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
                else:\r
                    ValueList.append(Sku.DefaultValue)\r
\r
                DbValueList.append(Sku.DefaultValue)\r
\r
        Pcd.TokenTypeList = sorted(set(Pcd.TokenTypeList))\r
        if Pcd.DatumType == TAB_VOID:\r
            Dict['SIZE_TABLE_CNAME'].append(CName)\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
        if 'PCD_TYPE_HII' in Pcd.TokenTypeList:\r
            Dict['VARIABLE_HEAD_CNAME_DECL'].append(CName)\r
            Dict['VARIABLE_HEAD_GUID_DECL'].append(TokenSpaceGuid)\r
            Dict['VARIABLE_HEAD_NUMSKUS_DECL'].append(len(Pcd.SkuInfoList))\r
            Dict['VARIABLE_HEAD_VALUE'].append('{ %s }\n' % ' },\n    { '.join(VariableHeadValueList))\r
            Dict['VARDEF_HEADER'].append('_Variable_Header')\r
            Dict['VARIABLE_DB_VALUE'].append(VariableDbValueList)\r
        else:\r
            Dict['VARDEF_HEADER'].append('')\r
        if 'PCD_TYPE_VPD' in Pcd.TokenTypeList:\r
            Dict['VPD_HEAD_CNAME_DECL'].append(CName)\r
            Dict['VPD_HEAD_GUID_DECL'].append(TokenSpaceGuid)\r
            Dict['VPD_HEAD_NUMSKUS_DECL'].append(len(Pcd.SkuInfoList))\r
            Dict['VPD_HEAD_VALUE'].append('{ %s }' % ' }, { '.join(VpdHeadOffsetList))\r
            Dict['VPD_DB_VALUE'].append(VpdDbOffsetList)\r
        if 'PCD_TYPE_STRING' in Pcd.TokenTypeList:\r
            Dict['STRING_HEAD_CNAME_DECL'].append(CName)\r
            Dict['STRING_HEAD_GUID_DECL'].append(TokenSpaceGuid)\r
            Dict['STRING_HEAD_NUMSKUS_DECL'].append(len(Pcd.SkuInfoList))\r
            Dict['STRING_HEAD_VALUE'].append(', '.join(StringHeadOffsetList))\r
            Dict['STRING_DB_VALUE'].append(StringDbOffsetList)\r
            PCD_STRING_INDEX_MAP[len(Dict['STRING_HEAD_CNAME_DECL']) -1 ] = len(Dict['STRING_DB_VALUE']) -1\r
        if 'PCD_TYPE_DATA' in Pcd.TokenTypeList:\r
            Dict[Pcd.InitString+'_CNAME_DECL_'+Pcd.DatumType].append(CName)\r
            Dict[Pcd.InitString+'_GUID_DECL_'+Pcd.DatumType].append(TokenSpaceGuid)\r
            Dict[Pcd.InitString+'_NUMSKUS_DECL_'+Pcd.DatumType].append(len(Pcd.SkuInfoList))\r
            if Pcd.InitString == 'UNINIT':\r
                Dict['PCD_DATABASE_UNINIT_EMPTY'] = ''\r
            else:\r
                Dict[Pcd.InitString+'_VALUE_'+Pcd.DatumType].append(', '.join(ValueList))\r
                Dict[Pcd.InitString+'_DB_VALUE_'+Pcd.DatumType].append(DbValueList)\r
\r
    if Phase == 'PEI':\r
        NumberOfLocalTokens = NumberOfPeiLocalTokens\r
    if Phase == 'DXE':\r
        NumberOfLocalTokens = NumberOfDxeLocalTokens\r
\r
    Dict['TOKEN_INIT']       = ['' for x in range(NumberOfLocalTokens)]\r
    Dict['TOKEN_CNAME']      = ['' for x in range(NumberOfLocalTokens)]\r
    Dict['TOKEN_GUID']       = ['' for x in range(NumberOfLocalTokens)]\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_CNAME_LENGTH'] = [0 for x in range(NumberOfLocalTokens)]\r
    SkuEnablePcdIndex = 0\r
    for Pcd in ReorderedDynPcdList:\r
        CName = Pcd.TokenCName\r
        TokenSpaceGuidCName = Pcd.TokenSpaceGuidCName\r
        if Pcd.Phase != Phase:\r
            continue\r
\r
        TokenSpaceGuid = GuidStructureStringToGuidValueName(Pcd.TokenSpaceGuidValue) #(Platform.PackageList, TokenSpaceGuidCName))\r
        GeneratedTokenNumber = Platform.PcdTokenNumber[CName, TokenSpaceGuidCName] - 1\r
        if Phase == 'DXE':\r
            GeneratedTokenNumber -= NumberOfPeiLocalTokens\r
\r
        if len(Pcd.SkuInfoList) > 1:\r
            Dict['PCD_ORDER_TOKEN_NUMBER_MAP'][GeneratedTokenNumber] = SkuEnablePcdIndex\r
            SkuEnablePcdIndex += 1\r
\r
        for PcdItem in GlobalData.MixedPcd:\r
            if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) in GlobalData.MixedPcd[PcdItem]:\r
                CName = PcdItem[0]\r
\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
        # following four Dict items hold the information for LocalTokenNumberTable\r
        #\r
        Dict['TOKEN_INIT'][GeneratedTokenNumber] = 'Init'\r
        if Pcd.InitString == 'UNINIT':\r
            Dict['TOKEN_INIT'][GeneratedTokenNumber] = 'Uninit'\r
\r
        Dict['TOKEN_CNAME'][GeneratedTokenNumber] = CName\r
        Dict['TOKEN_GUID'][GeneratedTokenNumber] = TokenSpaceGuid\r
        Dict['TOKEN_TYPE'][GeneratedTokenNumber] = ' | '.join(Pcd.TokenTypeList)\r
\r
        if Platform.Platform.PcdInfoFlag:\r
            TokenSpaceGuidCNameArray = StringToArray('"' + TokenSpaceGuidCName + '"' )\r
            if TokenSpaceGuidCNameArray not in Dict['PCD_TOKENSPACE']:\r
                Dict['PCD_TOKENSPACE'].append(TokenSpaceGuidCNameArray)\r
                Dict['PCD_TOKENSPACE_LENGTH'].append( len(TokenSpaceGuidCNameArray.split(",")) )\r
            Dict['PCD_TOKENSPACE_MAP'][GeneratedTokenNumber] = Dict['PCD_TOKENSPACE'].index(TokenSpaceGuidCNameArray)\r
            CNameBinArray = StringToArray('"' + CName + '"' )\r
            Dict['PCD_CNAME'][GeneratedTokenNumber] = CNameBinArray\r
\r
            Dict['PCD_CNAME_LENGTH'][GeneratedTokenNumber] = len(CNameBinArray.split(","))\r
\r
\r
        Pcd.TokenTypeList = sorted(set(Pcd.TokenTypeList))\r
\r
        # search the Offset and Table, used by LocalTokenNumberTableOffset\r
        if 'PCD_TYPE_HII' in Pcd.TokenTypeList:\r
            # Find index by CName, TokenSpaceGuid\r
            Offset = GetMatchedIndex(CName, Dict['VARIABLE_HEAD_CNAME_DECL'], TokenSpaceGuid, Dict['VARIABLE_HEAD_GUID_DECL'])\r
            assert(Offset != -1)\r
            Table = Dict['VARIABLE_DB_VALUE']\r
        if 'PCD_TYPE_VPD' in Pcd.TokenTypeList:\r
            Offset = GetMatchedIndex(CName, Dict['VPD_HEAD_CNAME_DECL'], TokenSpaceGuid, Dict['VPD_HEAD_GUID_DECL'])\r
            assert(Offset != -1)\r
            Table = Dict['VPD_DB_VALUE']\r
        if 'PCD_TYPE_STRING' in Pcd.TokenTypeList and 'PCD_TYPE_HII' not in Pcd.TokenTypeList:\r
            # Find index by CName, TokenSpaceGuid\r
            Offset = GetMatchedIndex(CName, Dict['STRING_HEAD_CNAME_DECL'], TokenSpaceGuid, Dict['STRING_HEAD_GUID_DECL'])\r
            Offset = PCD_STRING_INDEX_MAP[Offset]\r
            assert(Offset != -1)\r
            Table = Dict['STRING_DB_VALUE']\r
        if 'PCD_TYPE_DATA' in Pcd.TokenTypeList:\r
            # need to store whether it is in init table or not\r
            Offset = GetMatchedIndex(CName, Dict[Pcd.InitString+'_CNAME_DECL_'+Pcd.DatumType], TokenSpaceGuid, Dict[Pcd.InitString+'_GUID_DECL_'+Pcd.DatumType])\r
            assert(Offset != -1)\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
        Dict['LOCAL_TOKEN_NUMBER_DB_VALUE'][GeneratedTokenNumber] = (Offset, Table)\r
\r
        #\r
        # Update VARDEF_HEADER\r
        #\r
        if 'PCD_TYPE_HII' in Pcd.TokenTypeList:\r
            Dict['VARDEF_HEADER'][GeneratedTokenNumber] = '_Variable_Header'\r
        else:\r
            Dict['VARDEF_HEADER'][GeneratedTokenNumber] = ''\r
\r
\r
        if Pcd.Type in PCD_DYNAMIC_EX_TYPE_SET:\r
\r
            if Phase == 'DXE':\r
                GeneratedTokenNumber += NumberOfPeiLocalTokens\r
            #\r
            # Per, PCD architecture specification, PCD Token Number is 1 based and 0 is defined as invalid token number.\r
            # For each EX type PCD, a PCD Token Number is assigned. When the\r
            # PCD Driver/PEIM map EX_GUID and EX_TOKEN_NUMBER to the PCD Token Number,\r
            # the non-EX Protocol/PPI interface can be called to get/set the value. This assumption is made by\r
            # Pcd Driver/PEIM in MdeModulePkg.\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
            Dict['EXMAPPING_TABLE_EXTOKEN'].append(str(Pcd.TokenValue) + 'U')\r
            Dict['EXMAPPING_TABLE_LOCAL_TOKEN'].append(str(GeneratedTokenNumber + 1) + 'U')\r
            Dict['EXMAPPING_TABLE_GUID_INDEX'].append(str(GuidList.index(TokenSpaceGuid)) + 'U')\r
\r
    if Platform.Platform.PcdInfoFlag:\r
        for index in range(len(Dict['PCD_TOKENSPACE_MAP'])):\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
        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_NAME_OFFSET'].append(Dict['PCD_TOKENSPACE_OFFSET'][index])\r
            Dict['PCD_NAME_OFFSET'].append(StringTableSize)\r
            StringTableSize += Dict['PCD_CNAME_LENGTH'][index]\r
            StringTableIndex += 1\r
    if GuidList != []:\r
        Dict['GUID_TABLE_EMPTY'] = 'FALSE'\r
        Dict['GUID_TABLE_SIZE'] = str(len(GuidList)) + 'U'\r
    else:\r
        Dict['GUID_STRUCTURE'] = [GuidStringToGuidStructureString('00000000-0000-0000-0000-000000000000')]\r
\r
    if StringTableIndex == 0:\r
        Dict['STRING_TABLE_INDEX'].append('')\r
        Dict['STRING_TABLE_LENGTH'].append(1)\r
        Dict['STRING_TABLE_CNAME'].append('')\r
        Dict['STRING_TABLE_GUID'].append('')\r
        Dict['STRING_TABLE_VALUE'].append('{ 0 }')\r
    else:\r
        Dict['STRING_TABLE_EMPTY'] = 'FALSE'\r
        Dict['STRING_TABLE_SIZE'] = str(StringTableSize) + 'U'\r
\r
    if Dict['SIZE_TABLE_CNAME'] == []:\r
        Dict['SIZE_TABLE_CNAME'].append('')\r
        Dict['SIZE_TABLE_GUID'].append('')\r
        Dict['SIZE_TABLE_CURRENT_LENGTH'].append(['0U'])\r
        Dict['SIZE_TABLE_MAXIMUM_LENGTH'].append('0U')\r
\r
    if NumberOfLocalTokens != 0:\r
        Dict['DATABASE_EMPTY']                = 'FALSE'\r
        Dict['LOCAL_TOKEN_NUMBER_TABLE_SIZE'] = NumberOfLocalTokens\r
        Dict['LOCAL_TOKEN_NUMBER']            = NumberOfLocalTokens\r
\r
    if NumberOfExTokens != 0:\r
        Dict['EXMAP_TABLE_EMPTY']    = 'FALSE'\r
        Dict['EXMAPPING_TABLE_SIZE'] = str(NumberOfExTokens) + 'U'\r
        Dict['EX_TOKEN_NUMBER']      = str(NumberOfExTokens) + 'U'\r
    else:\r
        Dict['EXMAPPING_TABLE_EXTOKEN'].append('0U')\r
        Dict['EXMAPPING_TABLE_LOCAL_TOKEN'].append('0U')\r
        Dict['EXMAPPING_TABLE_GUID_INDEX'].append('0U')\r
\r
    if NumberOfSizeItems != 0:\r
        Dict['SIZE_TABLE_SIZE'] = str(NumberOfSizeItems * 2) + 'U'\r
\r
    if NumberOfSkuEnabledPcd != 0:\r
        Dict['SKU_HEAD_SIZE'] = str(NumberOfSkuEnabledPcd) + 'U'\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
    AutoGenH.Append(gPcdDatabaseAutoGenH.Replace(Dict))\r
    if NumberOfLocalTokens == 0:\r
        AutoGenC.Append(gEmptyPcdDatabaseAutoGenC.Replace(Dict))\r
    else:\r
        #\r
        # Update Size Table to the right order, it should be same with LocalTokenNumberTable\r
        #\r
        SizeCNameTempList = []\r
        SizeGuidTempList = []\r
        SizeCurLenTempList = []\r
        SizeMaxLenTempList = []\r
        ReOrderFlag = True\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
        if ReOrderFlag:\r
            for Count in range(len(Dict['TOKEN_CNAME'])):\r
                for Count1 in range(len(Dict['SIZE_TABLE_CNAME'])):\r
                    if Dict['TOKEN_CNAME'][Count] == Dict['SIZE_TABLE_CNAME'][Count1] and \\r
                        Dict['TOKEN_GUID'][Count] == Dict['SIZE_TABLE_GUID'][Count1]:\r
                        SizeCNameTempList.append(Dict['SIZE_TABLE_CNAME'][Count1])\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
            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
        AutoGenC.Append(gPcdDatabaseAutoGenC.Replace(Dict))\r
\r
\r
#     print Phase\r
    Buffer = BuildExDataBase(Dict)\r
    return AutoGenH, AutoGenC, Buffer, VarCheckTab\r
\r
def GetOrderedDynamicPcdList(DynamicPcdList, PcdTokenNumberList):\r
    ReorderedDyPcdList = [None for i in range(len(DynamicPcdList))]\r
    for Pcd in DynamicPcdList:\r
        if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) in PcdTokenNumberList:\r
            ReorderedDyPcdList[PcdTokenNumberList[Pcd.TokenCName, Pcd.TokenSpaceGuidCName]-1] = Pcd\r
    return ReorderedDyPcdList\r
\r