[mirror_edk2.git] / BaseTools / Source / Python / BPDG / GenVpd.py

## @file\r
#  This file include GenVpd class for fix the Vpd type PCD offset, and PcdEntry for describe\r
#  and process each entry of vpd type PCD.\r
#\r
#  Copyright (c) 2010 - 2018, Intel Corporation. All rights reserved.<BR>\r
#\r
#  This program and the accompanying materials\r
#  are licensed and made available under the terms and conditions of the BSD License\r
#  which accompanies this distribution.  The full text of the license may be found at\r
#  http://opensource.org/licenses/bsd-license.php\r
#\r
#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
#\r
\r
from __future__ import absolute_import\r
import Common.LongFilePathOs as os\r
from io import BytesIO\r
from . import StringTable as st\r
import array\r
import re\r
from Common.LongFilePathSupport import OpenLongFilePath as open\r
from struct import *\r
from Common.DataType import MAX_SIZE_TYPE, MAX_VAL_TYPE, TAB_STAR\r
import Common.EdkLogger as EdkLogger\r
import Common.BuildToolError as BuildToolError\r
\r
_FORMAT_CHAR = {1: 'B',\r
                2: 'H',\r
                4: 'I',\r
                8: 'Q'\r
                }\r
\r
## The VPD PCD data structure for store and process each VPD PCD entry.\r
#\r
#  This class contain method to format and pack pcd's value.\r
#\r
class PcdEntry:\r
    def __init__(self, PcdCName, SkuId,PcdOffset, PcdSize, PcdValue, Lineno=None, FileName=None, PcdUnpackValue=None,\r
                 PcdBinOffset=None, PcdBinSize=None, Alignment=None):\r
        self.PcdCName       = PcdCName.strip()\r
        self.SkuId          = SkuId.strip()\r
        self.PcdOffset      = PcdOffset.strip()\r
        self.PcdSize        = PcdSize.strip()\r
        self.PcdValue       = PcdValue.strip()\r
        self.Lineno         = Lineno.strip()\r
        self.FileName       = FileName.strip()\r
        self.PcdUnpackValue = PcdUnpackValue\r
        self.PcdBinOffset   = PcdBinOffset\r
        self.PcdBinSize     = PcdBinSize\r
        self.Alignment       = Alignment\r
\r
        if self.PcdValue == '' :\r
            EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID,\r
                            "Invalid PCD format(Name: %s File: %s line: %s) , no Value specified!" % (self.PcdCName, self.FileName, self.Lineno))\r
\r
        if self.PcdOffset == '' :\r
            EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID,\r
                            "Invalid PCD format(Name: %s File: %s Line: %s) , no Offset specified!" % (self.PcdCName, self.FileName, self.Lineno))\r
\r
        if self.PcdSize == '' :\r
            EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID,\r
                            "Invalid PCD format(Name: %s File: %s Line: %s), no PcdSize specified!" % (self.PcdCName, self.FileName, self.Lineno))\r
\r
        self._GenOffsetValue ()\r
\r
    ## Analyze the string value to judge the PCD's datum type equal to Boolean or not.\r
    #\r
    #  @param   ValueString      PCD's value\r
    #  @param   Size             PCD's size\r
    #\r
    #  @retval  True   PCD's datum type is Boolean\r
    #  @retval  False  PCD's datum type is not Boolean.\r
    #\r
    def _IsBoolean(self, ValueString, Size):\r
        if (Size == "1"):\r
            if ValueString.upper() in ["TRUE", "FALSE"]:\r
                return True\r
            elif ValueString in ["0", "1", "0x0", "0x1", "0x00", "0x01"]:\r
                return True\r
\r
        return False\r
\r
    ## Convert the PCD's value from string to integer.\r
    #\r
    #  This function will try to convert the Offset value form string to integer\r
    #  for both hexadecimal and decimal.\r
    #\r
    def _GenOffsetValue(self):\r
        if self.PcdOffset != TAB_STAR:\r
            try:\r
                self.PcdBinOffset = int (self.PcdOffset)\r
            except:\r
                try:\r
                    self.PcdBinOffset = int(self.PcdOffset, 16)\r
                except:\r
                    EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID,\r
                                    "Invalid offset value %s for PCD %s (File: %s Line: %s)" % (self.PcdOffset, self.PcdCName, self.FileName, self.Lineno))\r
\r
    ## Pack Boolean type VPD PCD's value form string to binary type.\r
    #\r
    #  @param ValueString     The boolean type string for pack.\r
    #\r
    #\r
    def _PackBooleanValue(self, ValueString):\r
        if ValueString.upper() == "TRUE" or ValueString in ["1", "0x1", "0x01"]:\r
            try:\r
                self.PcdValue = pack(_FORMAT_CHAR[1], 1)\r
            except:\r
                EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID,\r
                                "Invalid size or value for PCD %s to pack(File: %s Line: %s)." % (self.PcdCName, self.FileName, self.Lineno))\r
        else:\r
            try:\r
                self.PcdValue = pack(_FORMAT_CHAR[1], 0)\r
            except:\r
                EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID,\r
                                "Invalid size or value for PCD %s to pack(File: %s Line: %s)." % (self.PcdCName, self.FileName, self.Lineno))\r
\r
    ## Pack Integer type VPD PCD's value form string to binary type.\r
    #\r
    #  @param ValueString     The Integer type string for pack.\r
    #\r
    #\r
    def _PackIntValue(self, IntValue, Size):\r
        if Size not in _FORMAT_CHAR:\r
            EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID,\r
                            "Invalid size %d for PCD %s in integer datum size(File: %s Line: %s)." % (Size, self.PcdCName, self.FileName, self.Lineno))\r
\r
        for Type, MaxSize in MAX_SIZE_TYPE.items():\r
            if Type == 'BOOLEAN':\r
                continue\r
            if Size == MaxSize:\r
                if IntValue < 0:\r
                    EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID,\r
                                    "PCD can't be set to negative value %d for PCD %s in %s datum type(File: %s Line: %s)." % (\r
                                    IntValue, self.PcdCName, Type, self.FileName, self.Lineno))\r
                elif IntValue > MAX_VAL_TYPE[Type]:\r
                    EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID,\r
                                    "Too large PCD value %d for datum type %s for PCD %s(File: %s Line: %s)." % (\r
                                    IntValue, Type, self.PcdCName, self.FileName, self.Lineno))\r
\r
        try:\r
            self.PcdValue = pack(_FORMAT_CHAR[Size], IntValue)\r
        except:\r
            EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID,\r
                            "Invalid size or value for PCD %s to pack(File: %s Line: %s)." % (self.PcdCName, self.FileName, self.Lineno))\r
\r
    ## Pack VOID* type VPD PCD's value form string to binary type.\r
    #\r
    #  The VOID* type of string divided into 3 sub-type:\r
    #    1:    L"String"/L'String', Unicode type string.\r
    #    2:    "String"/'String',  Ascii type string.\r
    #    3:    {bytearray}, only support byte-array.\r
    #\r
    #  @param ValueString     The Integer type string for pack.\r
    #\r
    def _PackPtrValue(self, ValueString, Size):\r
        if ValueString.startswith('L"') or ValueString.startswith("L'"):\r
            self._PackUnicode(ValueString, Size)\r
        elif ValueString.startswith('{') and ValueString.endswith('}'):\r
            self._PackByteArray(ValueString, Size)\r
        elif (ValueString.startswith('"') and ValueString.endswith('"')) or (ValueString.startswith("'") and ValueString.endswith("'")):\r
            self._PackString(ValueString, Size)\r
        else:\r
            EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID,\r
                            "Invalid VOID* type PCD %s value %s (File: %s Line: %s)" % (self.PcdCName, ValueString, self.FileName, self.Lineno))\r
\r
    ## Pack an Ascii PCD value.\r
    #\r
    #  An Ascii string for a PCD should be in format as  ""/''.\r
    #\r
    def _PackString(self, ValueString, Size):\r
        if (Size < 0):\r
            EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID,\r
                            "Invalid parameter Size %s of PCD %s!(File: %s Line: %s)" % (self.PcdBinSize, self.PcdCName, self.FileName, self.Lineno))\r
        if (ValueString == ""):\r
            EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID, "Invalid parameter ValueString %s of PCD %s!(File: %s Line: %s)" % (self.PcdUnpackValue, self.PcdCName, self.FileName, self.Lineno))\r
\r
        QuotedFlag = True\r
        if ValueString.startswith("'"):\r
            QuotedFlag = False\r
\r
        ValueString = ValueString[1:-1]\r
        # No null-terminator in 'string'\r
        if (QuotedFlag and len(ValueString) + 1 > Size) or (not QuotedFlag and len(ValueString) > Size):\r
            EdkLogger.error("BPDG", BuildToolError.RESOURCE_OVERFLOW,\r
                            "PCD value string %s is exceed to size %d(File: %s Line: %s)" % (ValueString, Size, self.FileName, self.Lineno))\r
        try:\r
            self.PcdValue = pack('%ds' % Size, ValueString)\r
        except:\r
            EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID,\r
                            "Invalid size or value for PCD %s to pack(File: %s Line: %s)." % (self.PcdCName, self.FileName, self.Lineno))\r
\r
    ## Pack a byte-array PCD value.\r
    #\r
    #  A byte-array for a PCD should be in format as  {0x01, 0x02, ...}.\r
    #\r
    def _PackByteArray(self, ValueString, Size):\r
        if (Size < 0):\r
            EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID, "Invalid parameter Size %s of PCD %s!(File: %s Line: %s)" % (self.PcdBinSize, self.PcdCName, self.FileName, self.Lineno))\r
        if (ValueString == ""):\r
            EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID, "Invalid parameter ValueString %s of PCD %s!(File: %s Line: %s)" % (self.PcdUnpackValue, self.PcdCName, self.FileName, self.Lineno))\r
\r
        ValueString = ValueString.strip()\r
        ValueString = ValueString.lstrip('{').strip('}')\r
        ValueList = ValueString.split(',')\r
        ValueList = [item.strip() for item in ValueList]\r
\r
        if len(ValueList) > Size:\r
            EdkLogger.error("BPDG", BuildToolError.RESOURCE_OVERFLOW,\r
                            "The byte array %s is too large for size %d(File: %s Line: %s)" % (ValueString, Size, self.FileName, self.Lineno))\r
\r
        ReturnArray = array.array('B')\r
\r
        for Index in range(len(ValueList)):\r
            Value = None\r
            if ValueList[Index].lower().startswith('0x'):\r
                # translate hex value\r
                try:\r
                    Value = int(ValueList[Index], 16)\r
                except:\r
                    EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID,\r
                                    "The value item %s in byte array %s is an invalid HEX value.(File: %s Line: %s)" % \\r
                                    (ValueList[Index], ValueString, self.FileName, self.Lineno))\r
            else:\r
                # translate decimal value\r
                try:\r
                    Value = int(ValueList[Index], 10)\r
                except:\r
                    EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID,\r
                                    "The value item %s in byte array %s is an invalid DECIMAL value.(File: %s Line: %s)" % \\r
                                    (ValueList[Index], ValueString, self.FileName, self.Lineno))\r
\r
            if Value > 255:\r
                EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID,\r
                                "The value item %s in byte array %s do not in range 0 ~ 0xFF(File: %s Line: %s)" % \\r
                                (ValueList[Index], ValueString, self.FileName, self.Lineno))\r
\r
            ReturnArray.append(Value)\r
\r
        for Index in range(len(ValueList), Size):\r
            ReturnArray.append(0)\r
\r
        self.PcdValue = ReturnArray.tolist()\r
\r
    ## Pack a unicode PCD value into byte array.\r
    #\r
    #  A unicode string for a PCD should be in format as  L""/L''.\r
    #\r
    def _PackUnicode(self, UnicodeString, Size):\r
        if (Size < 0):\r
            EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID, "Invalid parameter Size %s of PCD %s!(File: %s Line: %s)" % \\r
                             (self.PcdBinSize, self.PcdCName, self.FileName, self.Lineno))\r
\r
        QuotedFlag = True\r
        if UnicodeString.startswith("L'"):\r
            QuotedFlag = False\r
        UnicodeString = UnicodeString[2:-1]\r
\r
        # No null-terminator in L'string'\r
        if (QuotedFlag and (len(UnicodeString) + 1) * 2 > Size) or (not QuotedFlag and len(UnicodeString) * 2 > Size):\r
            EdkLogger.error("BPDG", BuildToolError.RESOURCE_OVERFLOW,\r
                            "The size of unicode string %s is too larger for size %s(File: %s Line: %s)" % \\r
                            (UnicodeString, Size, self.FileName, self.Lineno))\r
\r
        ReturnArray = array.array('B')\r
        for Value in UnicodeString:\r
            try:\r
                ReturnArray.append(ord(Value))\r
                ReturnArray.append(0)\r
            except:\r
                EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID,\r
                                "Invalid unicode character %s in unicode string %s(File: %s Line: %s)" % \\r
                                (Value, UnicodeString, self.FileName, self.Lineno))\r
\r
        for Index in range(len(UnicodeString) * 2, Size):\r
            ReturnArray.append(0)\r
\r
        self.PcdValue = ReturnArray.tolist()\r
\r
\r
\r
## The class implementing the BPDG VPD PCD offset fix process\r
#\r
#   The VPD PCD offset fix process includes:\r
#       1. Parse the input guided.txt file and store it in the data structure;\r
#       2. Format the input file data to remove unused lines;\r
#       3. Fixed offset if needed;\r
#       4. Generate output file, including guided.map and guided.bin file;\r
#\r
class GenVPD :\r
    ## Constructor of DscBuildData\r
    #\r
    #  Initialize object of GenVPD\r
    #   @Param      InputFileName   The filename include the vpd type pcd information\r
    #   @param      MapFileName     The filename of map file that stores vpd type pcd information.\r
    #                               This file will be generated by the BPDG tool after fix the offset\r
    #                               and adjust the offset to make the pcd data aligned.\r
    #   @param      VpdFileName     The filename of Vpd file that hold vpd pcd information.\r
    #\r
    def __init__(self, InputFileName, MapFileName, VpdFileName):\r
        self.InputFileName           = InputFileName\r
        self.MapFileName             = MapFileName\r
        self.VpdFileName             = VpdFileName\r
        self.FileLinesList           = []\r
        self.PcdFixedOffsetSizeList  = []\r
        self.PcdUnknownOffsetList    = []\r
        try:\r
            fInputfile = open(InputFileName, "r", 0)\r
            try:\r
                self.FileLinesList = fInputfile.readlines()\r
            except:\r
                EdkLogger.error("BPDG", BuildToolError.FILE_READ_FAILURE, "File read failed for %s" % InputFileName, None)\r
            finally:\r
                fInputfile.close()\r
        except:\r
            EdkLogger.error("BPDG", BuildToolError.FILE_OPEN_FAILURE, "File open failed for %s" % InputFileName, None)\r
\r
    ##\r
    # Parser the input file which is generated by the build tool. Convert the value of each pcd's\r
    # from string to it's real format. Also remove the useless line in the input file.\r
    #\r
    def ParserInputFile (self):\r
        count = 0\r
        for line in self.FileLinesList:\r
            # Strip "\r\n" generated by readlines ().\r
            line = line.strip()\r
            line = line.rstrip(os.linesep)\r
\r
            # Skip the comment line\r
            if (not line.startswith("#")) and len(line) > 1 :\r
                #\r
                # Enhanced for support "|" character in the string.\r
                #\r
                ValueList = ['', '', '', '', '']\r
\r
                ValueRe = re.compile(r'\s*L?\".*\|.*\"\s*$')\r
                PtrValue = ValueRe.findall(line)\r
\r
                ValueUpdateFlag = False\r
\r
                if len(PtrValue) >= 1:\r
                    line = re.sub(ValueRe, '', line)\r
                    ValueUpdateFlag = True\r
\r
                TokenList = line.split('|')\r
                ValueList[0:len(TokenList)] = TokenList\r
\r
                if ValueUpdateFlag:\r
                    ValueList[4] = PtrValue[0]\r
                self.FileLinesList[count] = ValueList\r
                # Store the line number\r
                self.FileLinesList[count].append(str(count + 1))\r
            elif len(line) <= 1 :\r
                # Set the blank line to "None"\r
                self.FileLinesList[count] = None\r
            else :\r
                # Set the comment line to "None"\r
                self.FileLinesList[count] = None\r
            count += 1\r
\r
        # The line count contain usage information\r
        count = 0\r
        # Delete useless lines\r
        while (True) :\r
            try :\r
                if (self.FileLinesList[count] is None) :\r
                    del(self.FileLinesList[count])\r
                else :\r
                    count += 1\r
            except :\r
                break\r
        #\r
        # After remove the useless line, if there are no data remain in the file line list,\r
        # Report warning messages to user's.\r
        #\r
        if len(self.FileLinesList) == 0 :\r
            EdkLogger.warn('BPDG', BuildToolError.RESOURCE_NOT_AVAILABLE,\r
                           "There are no VPD type pcds defined in DSC file, Please check it.")\r
\r
        # Process the pcds one by one base on the pcd's value and size\r
        count = 0\r
        for line in self.FileLinesList:\r
            if line is not None :\r
                PCD = PcdEntry(line[0], line[1], line[2], line[3], line[4], line[5], self.InputFileName)\r
                # Strip the space char\r
                PCD.PcdCName     = PCD.PcdCName.strip(' ')\r
                PCD.SkuId        = PCD.SkuId.strip(' ')\r
                PCD.PcdOffset    = PCD.PcdOffset.strip(' ')\r
                PCD.PcdSize      = PCD.PcdSize.strip(' ')\r
                PCD.PcdValue     = PCD.PcdValue.strip(' ')\r
                PCD.Lineno       = PCD.Lineno.strip(' ')\r
\r
                #\r
                # Store the original pcd value.\r
                # This information will be useful while generate the output map file.\r
                #\r
                PCD.PcdUnpackValue    =  str(PCD.PcdValue)\r
\r
                #\r
                # Translate PCD size string to an integer value.\r
                PackSize = None\r
                try:\r
                    PackSize = int(PCD.PcdSize, 10)\r
                    PCD.PcdBinSize = PackSize\r
                except:\r
                    try:\r
                        PackSize = int(PCD.PcdSize, 16)\r
                        PCD.PcdBinSize = PackSize\r
                    except:\r
                        EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID, "Invalid PCD size value %s at file: %s line: %s" % (PCD.PcdSize, self.InputFileName, PCD.Lineno))\r
\r
                #\r
                # If value is Unicode string (e.g. L""), then use 2-byte alignment\r
                # If value is byte array (e.g. {}), then use 8-byte alignment\r
                #\r
                PCD.PcdOccupySize = PCD.PcdBinSize\r
                if PCD.PcdUnpackValue.startswith("{"):\r
                    Alignment = 8\r
                elif PCD.PcdUnpackValue.startswith("L"):\r
                    Alignment = 2\r
                else:\r
                    Alignment = 1\r
\r
                PCD.Alignment = Alignment\r
                if PCD.PcdOffset != TAB_STAR:\r
                    if PCD.PcdOccupySize % Alignment != 0:\r
                        if PCD.PcdUnpackValue.startswith("{"):\r
                            EdkLogger.warn("BPDG", "The offset value of PCD %s is not 8-byte aligned!" %(PCD.PcdCName), File=self.InputFileName)\r
                        else:\r
                            EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID, 'The offset value of PCD %s should be %s-byte aligned.' % (PCD.PcdCName, Alignment))\r
                else:\r
                    if PCD.PcdOccupySize % Alignment != 0:\r
                        PCD.PcdOccupySize = (PCD.PcdOccupySize / Alignment + 1) * Alignment\r
\r
                PackSize = PCD.PcdOccupySize\r
                if PCD._IsBoolean(PCD.PcdValue, PCD.PcdSize):\r
                    PCD._PackBooleanValue(PCD.PcdValue)\r
                    self.FileLinesList[count] = PCD\r
                    count += 1\r
                    continue\r
                #\r
                # Try to translate value to an integer firstly.\r
                #\r
                IsInteger = True\r
                PackValue = None\r
                try:\r
                    PackValue = int(PCD.PcdValue)\r
                except:\r
                    try:\r
                        PackValue = int(PCD.PcdValue, 16)\r
                    except:\r
                        IsInteger = False\r
\r
                if IsInteger:\r
                    PCD._PackIntValue(PackValue, PackSize)\r
                else:\r
                    PCD._PackPtrValue(PCD.PcdValue, PackSize)\r
\r
                self.FileLinesList[count] = PCD\r
                count += 1\r
            else :\r
                continue\r
\r
    ##\r
    # This function used to create a clean list only contain useful information and reorganized to make it\r
    # easy to be sorted\r
    #\r
    def FormatFileLine (self) :\r
\r
        for eachPcd in self.FileLinesList :\r
            if eachPcd.PcdOffset != TAB_STAR :\r
                # Use pcd's Offset value as key, and pcd's Value as value\r
                self.PcdFixedOffsetSizeList.append(eachPcd)\r
            else :\r
                # Use pcd's CName as key, and pcd's Size as value\r
                self.PcdUnknownOffsetList.append(eachPcd)\r
\r
\r
    ##\r
    # This function is use to fix the offset value which the not specified in the map file.\r
    # Usually it use the star (meaning any offset) character in the offset field\r
    #\r
    def FixVpdOffset (self):\r
        # At first, the offset should start at 0\r
        # Sort fixed offset list in order to find out where has free spaces for the pcd's offset\r
        # value is TAB_STAR to insert into.\r
\r
        self.PcdFixedOffsetSizeList.sort(key=lambda x: x.PcdBinOffset)\r
\r
        #\r
        # Sort the un-fixed pcd's offset by it's size.\r
        #\r
        self.PcdUnknownOffsetList.sort(key=lambda x: x.PcdBinSize)\r
\r
        index =0\r
        for pcd in self.PcdUnknownOffsetList:\r
            index += 1\r
            if pcd.PcdCName == ".".join(("gEfiMdeModulePkgTokenSpaceGuid", "PcdNvStoreDefaultValueBuffer")):\r
                if index != len(self.PcdUnknownOffsetList):\r
                    for i in range(len(self.PcdUnknownOffsetList) - index):\r
                        self.PcdUnknownOffsetList[index+i -1 ], self.PcdUnknownOffsetList[index+i] = self.PcdUnknownOffsetList[index+i], self.PcdUnknownOffsetList[index+i -1]\r
\r
        #\r
        # Process all Offset value are TAB_STAR\r
        #\r
        if (len(self.PcdFixedOffsetSizeList) == 0) and (len(self.PcdUnknownOffsetList) != 0) :\r
            # The offset start from 0\r
            NowOffset = 0\r
            for Pcd in self.PcdUnknownOffsetList :\r
                if NowOffset % Pcd.Alignment != 0:\r
                    NowOffset = (NowOffset/ Pcd.Alignment + 1) * Pcd.Alignment\r
                Pcd.PcdBinOffset = NowOffset\r
                Pcd.PcdOffset    = str(hex(Pcd.PcdBinOffset))\r
                NowOffset       += Pcd.PcdOccupySize\r
\r
            self.PcdFixedOffsetSizeList = self.PcdUnknownOffsetList\r
            return\r
\r
        # Check the offset of VPD type pcd's offset start from 0.\r
        if self.PcdFixedOffsetSizeList[0].PcdBinOffset != 0 :\r
            EdkLogger.warn("BPDG", "The offset of VPD type pcd should start with 0, please check it.",\r
                            None)\r
\r
        # Judge whether the offset in fixed pcd offset list is overlapped or not.\r
        lenOfList = len(self.PcdFixedOffsetSizeList)\r
        count     = 0\r
        while (count < lenOfList - 1) :\r
            PcdNow  = self.PcdFixedOffsetSizeList[count]\r
            PcdNext = self.PcdFixedOffsetSizeList[count+1]\r
            # Two pcd's offset is same\r
            if PcdNow.PcdBinOffset == PcdNext.PcdBinOffset :\r
                EdkLogger.error("BPDG", BuildToolError.ATTRIBUTE_GET_FAILURE,\r
                                "The offset of %s at line: %s is same with %s at line: %s in file %s" % \\r
                                (PcdNow.PcdCName, PcdNow.Lineno, PcdNext.PcdCName, PcdNext.Lineno, PcdNext.FileName),\r
                                None)\r
\r
            # Overlapped\r
            if PcdNow.PcdBinOffset + PcdNow.PcdOccupySize > PcdNext.PcdBinOffset :\r
                EdkLogger.error("BPDG", BuildToolError.ATTRIBUTE_GET_FAILURE,\r
                                "The offset of %s at line: %s is overlapped with %s at line: %s in file %s" % \\r
                                (PcdNow.PcdCName, PcdNow.Lineno, PcdNext.PcdCName, PcdNext.Lineno, PcdNext.FileName),\r
                                None)\r
\r
            # Has free space, raise a warning message\r
            if PcdNow.PcdBinOffset + PcdNow.PcdOccupySize < PcdNext.PcdBinOffset :\r
                EdkLogger.warn("BPDG", BuildToolError.ATTRIBUTE_GET_FAILURE,\r
                               "The offsets have free space of between %s at line: %s and %s at line: %s in file %s" % \\r
                               (PcdNow.PcdCName, PcdNow.Lineno, PcdNext.PcdCName, PcdNext.Lineno, PcdNext.FileName),\r
                                None)\r
            count += 1\r
\r
        LastOffset              = self.PcdFixedOffsetSizeList[0].PcdBinOffset\r
        FixOffsetSizeListCount  = 0\r
        lenOfList               = len(self.PcdFixedOffsetSizeList)\r
        lenOfUnfixedList        = len(self.PcdUnknownOffsetList)\r
\r
        ##\r
        # Insert the un-fixed offset pcd's list into fixed offset pcd's list if has free space between those pcds.\r
        #\r
        while (FixOffsetSizeListCount < lenOfList) :\r
\r
            eachFixedPcd     = self.PcdFixedOffsetSizeList[FixOffsetSizeListCount]\r
            NowOffset        = eachFixedPcd.PcdBinOffset\r
\r
            # Has free space\r
            if LastOffset < NowOffset :\r
                if lenOfUnfixedList != 0 :\r
                    countOfUnfixedList = 0\r
                    while(countOfUnfixedList < lenOfUnfixedList) :\r
                        eachUnfixedPcd      = self.PcdUnknownOffsetList[countOfUnfixedList]\r
                        needFixPcdSize      = eachUnfixedPcd.PcdOccupySize\r
                        # Not been fixed\r
                        if eachUnfixedPcd.PcdOffset == TAB_STAR :\r
                            if LastOffset % eachUnfixedPcd.Alignment != 0:\r
                                LastOffset = (LastOffset / eachUnfixedPcd.Alignment + 1) * eachUnfixedPcd.Alignment\r
                            # The offset un-fixed pcd can write into this free space\r
                            if needFixPcdSize <= (NowOffset - LastOffset) :\r
                                # Change the offset value of un-fixed pcd\r
                                eachUnfixedPcd.PcdOffset    = str(hex(LastOffset))\r
                                eachUnfixedPcd.PcdBinOffset = LastOffset\r
                                # Insert this pcd into fixed offset pcd list.\r
                                self.PcdFixedOffsetSizeList.insert(FixOffsetSizeListCount, eachUnfixedPcd)\r
\r
                                # Delete the item's offset that has been fixed and added into fixed offset list\r
                                self.PcdUnknownOffsetList.pop(countOfUnfixedList)\r
\r
                                # After item added, should enlarge the length of fixed pcd offset list\r
                                lenOfList               += 1\r
                                FixOffsetSizeListCount  += 1\r
\r
                                # Decrease the un-fixed pcd offset list's length\r
                                lenOfUnfixedList        -= 1\r
\r
                                # Modify the last offset value\r
                                LastOffset              += needFixPcdSize\r
                            else :\r
                                # It can not insert into those two pcds, need to check still has other space can store it.\r
                                LastOffset             = NowOffset + self.PcdFixedOffsetSizeList[FixOffsetSizeListCount].PcdOccupySize\r
                                FixOffsetSizeListCount += 1\r
                                break\r
\r
                # Set the FixOffsetSizeListCount = lenOfList for quit the loop\r
                else :\r
                    FixOffsetSizeListCount = lenOfList\r
\r
            # No free space, smoothly connect with previous pcd.\r
            elif LastOffset == NowOffset :\r
                LastOffset = NowOffset + eachFixedPcd.PcdOccupySize\r
                FixOffsetSizeListCount += 1\r
            # Usually it will not enter into this thunk, if so, means it overlapped.\r
            else :\r
                EdkLogger.error("BPDG", BuildToolError.ATTRIBUTE_NOT_AVAILABLE,\r
                                "The offset value definition has overlapped at pcd: %s, it's offset is: %s, in file: %s line: %s" % \\r
                                (eachFixedPcd.PcdCName, eachFixedPcd.PcdOffset, eachFixedPcd.InputFileName, eachFixedPcd.Lineno),\r
                                None)\r
                FixOffsetSizeListCount += 1\r
\r
        # Continue to process the un-fixed offset pcd's list, add this time, just append them behind the fixed pcd's offset list.\r
        lenOfUnfixedList  = len(self.PcdUnknownOffsetList)\r
        lenOfList         = len(self.PcdFixedOffsetSizeList)\r
        while (lenOfUnfixedList > 0) :\r
            # Still has items need to process\r
            # The last pcd instance\r
            LastPcd    = self.PcdFixedOffsetSizeList[lenOfList-1]\r
            NeedFixPcd = self.PcdUnknownOffsetList[0]\r
\r
            NeedFixPcd.PcdBinOffset = LastPcd.PcdBinOffset + LastPcd.PcdOccupySize\r
            if NeedFixPcd.PcdBinOffset % NeedFixPcd.Alignment != 0:\r
                NeedFixPcd.PcdBinOffset = (NeedFixPcd.PcdBinOffset / NeedFixPcd.Alignment + 1) * NeedFixPcd.Alignment\r
\r
            NeedFixPcd.PcdOffset    = str(hex(NeedFixPcd.PcdBinOffset))\r
\r
            # Insert this pcd into fixed offset pcd list's tail.\r
            self.PcdFixedOffsetSizeList.insert(lenOfList, NeedFixPcd)\r
            # Delete the item's offset that has been fixed and added into fixed offset list\r
            self.PcdUnknownOffsetList.pop(0)\r
\r
            lenOfList          += 1\r
            lenOfUnfixedList   -= 1\r
    ##\r
    # Write the final data into output files.\r
    #\r
    def GenerateVpdFile (self, MapFileName, BinFileName):\r
        #Open an VPD file to process\r
\r
        try:\r
            fVpdFile = open(BinFileName, "wb", 0)\r
        except:\r
            # Open failed\r
            EdkLogger.error("BPDG", BuildToolError.FILE_OPEN_FAILURE, "File open failed for %s" % self.VpdFileName, None)\r
\r
        try :\r
            fMapFile = open(MapFileName, "w", 0)\r
        except:\r
            # Open failed\r
            EdkLogger.error("BPDG", BuildToolError.FILE_OPEN_FAILURE, "File open failed for %s" % self.MapFileName, None)\r
\r
        # Use a instance of BytesIO to cache data\r
        fStringIO = BytesIO('')\r
\r
        # Write the header of map file.\r
        try :\r
            fMapFile.write (st.MAP_FILE_COMMENT_TEMPLATE + "\n")\r
        except:\r
            EdkLogger.error("BPDG", BuildToolError.FILE_WRITE_FAILURE, "Write data to file %s failed, please check whether the file been locked or using by other applications." % self.MapFileName, None)\r
\r
        for eachPcd in self.PcdFixedOffsetSizeList  :\r
            # write map file\r
            try :\r
                fMapFile.write("%s | %s | %s | %s | %s  \n" % (eachPcd.PcdCName, eachPcd.SkuId, eachPcd.PcdOffset, eachPcd.PcdSize, eachPcd.PcdUnpackValue))\r
            except:\r
                EdkLogger.error("BPDG", BuildToolError.FILE_WRITE_FAILURE, "Write data to file %s failed, please check whether the file been locked or using by other applications." % self.MapFileName, None)\r
\r
            # Write Vpd binary file\r
            fStringIO.seek (eachPcd.PcdBinOffset)\r
            if isinstance(eachPcd.PcdValue, list):\r
                ValueList = [chr(Item) for Item in eachPcd.PcdValue]\r
                fStringIO.write(''.join(ValueList))\r
            else:\r
                fStringIO.write (eachPcd.PcdValue)\r
\r
        try :\r
            fVpdFile.write (fStringIO.getvalue())\r
        except:\r
            EdkLogger.error("BPDG", BuildToolError.FILE_WRITE_FAILURE, "Write data to file %s failed, please check whether the file been locked or using by other applications." % self.VpdFileName, None)\r
\r
        fStringIO.close ()\r
        fVpdFile.close ()\r
        fMapFile.close ()\r
\r