BaseTools: Adjust the spaces around commas and colons

[mirror_edk2.git] / BaseTools / Source / Python / Workspace / DscBuildData.py

## @file\r
# This file is used to create a database used by build tool\r
#\r
# Copyright (c) 2008 - 2018, Intel Corporation. All rights reserved.<BR>\r
# (C) Copyright 2016 Hewlett Packard Enterprise Development LP<BR>\r
# This program and the accompanying materials\r
# are licensed and made available under the terms and conditions of the BSD License\r
# which accompanies this distribution.  The full text of the license may be found at\r
# http://opensource.org/licenses/bsd-license.php\r
#\r
# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
#\r
\r
## Platform build information from DSC file\r
#\r
#  This class is used to retrieve information stored in database and convert them\r
# into PlatformBuildClassObject form for easier use for AutoGen.\r
#\r
from __future__ import print_function\r
from Common.StringUtils import *\r
from Common.DataType import *\r
from Common.Misc import *\r
from types import *\r
from Common.Expression import *\r
from CommonDataClass.CommonClass import SkuInfoClass\r
from Common.TargetTxtClassObject import *\r
from Common.ToolDefClassObject import *\r
from MetaDataTable import *\r
from MetaFileTable import *\r
from MetaFileParser import *\r
\r
from WorkspaceCommon import GetDeclaredPcd\r
from Common.Misc import AnalyzeDscPcd\r
from Common.Misc import ProcessDuplicatedInf\r
import re\r
from Common.Parsing import IsValidWord\r
from Common.VariableAttributes import VariableAttributes\r
import Common.GlobalData as GlobalData\r
import subprocess\r
from Common.Misc import SaveFileOnChange\r
from Workspace.BuildClassObject import PlatformBuildClassObject, StructurePcd, PcdClassObject, ModuleBuildClassObject\r
from collections import OrderedDict, defaultdict\r
\r
PcdValueInitName = 'PcdValueInit'\r
\r
PcdMainCHeader = '''\r
/**\r
  DO NOT EDIT\r
  FILE auto-generated\r
**/\r
\r
#include <stdio.h>\r
#include <stdlib.h>\r
#include <string.h>\r
#include <PcdValueCommon.h>\r
'''\r
\r
PcdMainCEntry = '''\r
int\r
main (\r
  int   argc,\r
  char  *argv[]\r
  )\r
{\r
  return PcdValueMain (argc, argv);\r
}\r
'''\r
\r
PcdMakefileHeader = '''\r
#\r
# DO NOT EDIT\r
# This file is auto-generated by build utility\r
#\r
\r
'''\r
\r
WindowsCFLAGS = 'CFLAGS = $(CFLAGS) /wd4200 /wd4034 /wd4101 '\r
LinuxCFLAGS = 'BUILD_CFLAGS += -Wno-pointer-to-int-cast -Wno-unused-variable '\r
PcdMakefileEnd = '''\r
!INCLUDE $(BASE_TOOLS_PATH)\Source\C\Makefiles\ms.common\r
\r
LIBS = $(LIB_PATH)\Common.lib\r
\r
!INCLUDE $(BASE_TOOLS_PATH)\Source\C\Makefiles\ms.app\r
'''\r
\r
PcdGccMakefile = '''\r
MAKEROOT ?= $(EDK_TOOLS_PATH)/Source/C\r
LIBS = -lCommon\r
'''\r
\r
variablePattern = re.compile(r'[\t\s]*0[xX][a-fA-F0-9]+$')\r
\r
## regular expressions for finding decimal and hex numbers\r
Pattern = re.compile('^[1-9]\d*|0$')\r
HexPattern = re.compile(r'0[xX][0-9a-fA-F]+$')\r
## Regular expression for finding header file inclusions\r
from AutoGen.GenMake import gIncludePattern\r
\r
## Find dependencies for one source file\r
#\r
#  By searching recursively "#include" directive in file, find out all the\r
#  files needed by given source file. The dependecies will be only searched\r
#  in given search path list.\r
#\r
#   @param      SearchPathList  The list of search path\r
#\r
#   @retval     list            The list of files the given source file depends on\r
#\r
def GetDependencyList(FileStack, SearchPathList):\r
    DepDb = dict()\r
    DependencySet = set(FileStack)\r
    while len(FileStack) > 0:\r
        F = FileStack.pop()\r
        FullPathDependList = []\r
        CurrentFileDependencyList = []\r
        if F in DepDb:\r
            CurrentFileDependencyList = DepDb[F]\r
        else:\r
            try:\r
                Fd = open(F, 'r')\r
                FileContent = Fd.read()\r
            except BaseException as X:\r
                EdkLogger.error("build", FILE_OPEN_FAILURE, ExtraData=F + "\n\t" + str(X))\r
            finally:\r
                if "Fd" in dir(locals()):\r
                    Fd.close()\r
\r
            if len(FileContent) == 0:\r
                continue\r
\r
            if FileContent[0] == 0xff or FileContent[0] == 0xfe:\r
                FileContent = unicode(FileContent, "utf-16")\r
            IncludedFileList = gIncludePattern.findall(FileContent)\r
\r
            for Inc in IncludedFileList:\r
                Inc = Inc.strip()\r
                Inc = os.path.normpath(Inc)\r
                CurrentFileDependencyList.append(Inc)\r
            DepDb[F] = CurrentFileDependencyList\r
\r
        CurrentFilePath = os.path.dirname(F)\r
        PathList = [CurrentFilePath] + SearchPathList\r
        for Inc in CurrentFileDependencyList:\r
            for SearchPath in PathList:\r
                FilePath = os.path.join(SearchPath, Inc)\r
                if not os.path.exists(FilePath):\r
                    continue\r
                if FilePath not in DependencySet:\r
                    FileStack.append(FilePath)\r
                    FullPathDependList.append(FilePath)\r
                break\r
        DependencySet.update(FullPathDependList)\r
    DependencyList = list(DependencySet)  # remove duplicate ones\r
\r
    return DependencyList\r
\r
class DscBuildData(PlatformBuildClassObject):\r
    # dict used to convert PCD type in database to string used by build tool\r
    _PCD_TYPE_STRING_ = {\r
        MODEL_PCD_FIXED_AT_BUILD        :   TAB_PCDS_FIXED_AT_BUILD,\r
        MODEL_PCD_PATCHABLE_IN_MODULE   :   TAB_PCDS_PATCHABLE_IN_MODULE,\r
        MODEL_PCD_FEATURE_FLAG          :   TAB_PCDS_FEATURE_FLAG,\r
        MODEL_PCD_DYNAMIC               :   TAB_PCDS_DYNAMIC,\r
        MODEL_PCD_DYNAMIC_DEFAULT       :   TAB_PCDS_DYNAMIC,\r
        MODEL_PCD_DYNAMIC_HII           :   TAB_PCDS_DYNAMIC_HII,\r
        MODEL_PCD_DYNAMIC_VPD           :   TAB_PCDS_DYNAMIC_VPD,\r
        MODEL_PCD_DYNAMIC_EX            :   TAB_PCDS_DYNAMIC_EX,\r
        MODEL_PCD_DYNAMIC_EX_DEFAULT    :   TAB_PCDS_DYNAMIC_EX,\r
        MODEL_PCD_DYNAMIC_EX_HII        :   TAB_PCDS_DYNAMIC_EX_HII,\r
        MODEL_PCD_DYNAMIC_EX_VPD        :   TAB_PCDS_DYNAMIC_EX_VPD,\r
    }\r
\r
    # dict used to convert part of [Defines] to members of DscBuildData directly\r
    _PROPERTY_ = {\r
        #\r
        # Required Fields\r
        #\r
        TAB_DSC_DEFINES_PLATFORM_NAME           :   "_PlatformName",\r
        TAB_DSC_DEFINES_PLATFORM_GUID           :   "_Guid",\r
        TAB_DSC_DEFINES_PLATFORM_VERSION        :   "_Version",\r
        TAB_DSC_DEFINES_DSC_SPECIFICATION       :   "_DscSpecification",\r
        # TAB_DSC_DEFINES_OUTPUT_DIRECTORY        :   "_OutputDirectory",\r
        # TAB_DSC_DEFINES_SUPPORTED_ARCHITECTURES :   "_SupArchList",\r
        # TAB_DSC_DEFINES_BUILD_TARGETS           :   "_BuildTargets",\r
        TAB_DSC_DEFINES_SKUID_IDENTIFIER        :   "_SkuName",\r
        # TAB_DSC_DEFINES_FLASH_DEFINITION        :   "_FlashDefinition",\r
        TAB_DSC_DEFINES_BUILD_NUMBER            :   "_BuildNumber",\r
        TAB_DSC_DEFINES_MAKEFILE_NAME           :   "_MakefileName",\r
        TAB_DSC_DEFINES_BS_BASE_ADDRESS         :   "_BsBaseAddress",\r
        TAB_DSC_DEFINES_RT_BASE_ADDRESS         :   "_RtBaseAddress",\r
        # TAB_DSC_DEFINES_RFC_LANGUAGES           :   "_RFCLanguages",\r
        # TAB_DSC_DEFINES_ISO_LANGUAGES           :   "_ISOLanguages",\r
    }\r
\r
    # used to compose dummy library class name for those forced library instances\r
    _NullLibraryNumber = 0\r
\r
    ## Constructor of DscBuildData\r
    #\r
    #  Initialize object of DscBuildData\r
    #\r
    #   @param      FilePath        The path of platform description file\r
    #   @param      RawData         The raw data of DSC file\r
    #   @param      BuildDataBase   Database used to retrieve module/package information\r
    #   @param      Arch            The target architecture\r
    #   @param      Platform        (not used for DscBuildData)\r
    #   @param      Macros          Macros used for replacement in DSC file\r
    #\r
    def __init__(self, FilePath, RawData, BuildDataBase, Arch=TAB_ARCH_COMMON, Target=None, Toolchain=None):\r
        self.MetaFile = FilePath\r
        self._RawData = RawData\r
        self._Bdb = BuildDataBase\r
        self._Arch = Arch\r
        self._Target = Target\r
        self._Toolchain = Toolchain\r
        self._ToolChainFamily = None\r
        self._Clear()\r
        self._HandleOverridePath()\r
        self.WorkspaceDir = os.getenv("WORKSPACE") if os.getenv("WORKSPACE") else ""\r
        self.DefaultStores = None\r
        self.SkuIdMgr = SkuClass(self.SkuName, self.SkuIds)\r
    @property\r
    def OutputPath(self):\r
        if os.getenv("WORKSPACE"):\r
            return os.path.join(os.getenv("WORKSPACE"), self.OutputDirectory, self._Target + "_" + self._Toolchain, PcdValueInitName)\r
        else:\r
            return os.path.dirname(self.DscFile)\r
\r
    ## XXX[key] = value\r
    def __setitem__(self, key, value):\r
        self.__dict__[self._PROPERTY_[key]] = value\r
\r
    ## value = XXX[key]\r
    def __getitem__(self, key):\r
        return self.__dict__[self._PROPERTY_[key]]\r
\r
    ## "in" test support\r
    def __contains__(self, key):\r
        return key in self._PROPERTY_\r
\r
    ## Set all internal used members of DscBuildData to None\r
    def _Clear(self):\r
        self._Header            = None\r
        self._PlatformName      = None\r
        self._Guid              = None\r
        self._Version           = None\r
        self._DscSpecification  = None\r
        self._OutputDirectory   = None\r
        self._SupArchList       = None\r
        self._BuildTargets      = None\r
        self._SkuName           = None\r
        self._PcdInfoFlag       = None\r
        self._VarCheckFlag      = None\r
        self._FlashDefinition   = None\r
        self._Prebuild          = None\r
        self._Postbuild         = None\r
        self._BuildNumber       = None\r
        self._MakefileName      = None\r
        self._BsBaseAddress     = None\r
        self._RtBaseAddress     = None\r
        self._SkuIds            = None\r
        self._Modules           = None\r
        self._LibraryInstances  = None\r
        self._LibraryClasses    = None\r
        self._Pcds              = None\r
        self._DecPcds           = None\r
        self._BuildOptions      = None\r
        self._ModuleTypeOptions = None\r
        self._LoadFixAddress    = None\r
        self._RFCLanguages      = None\r
        self._ISOLanguages      = None\r
        self._VpdToolGuid       = None\r
        self.__Macros           = None\r
        self.DefaultStores      = None\r
\r
\r
    ## handle Override Path of Module\r
    def _HandleOverridePath(self):\r
        RecordList = self._RawData[MODEL_META_DATA_COMPONENT, self._Arch]\r
        for Record in RecordList:\r
            ModuleId = Record[6]\r
            LineNo = Record[7]\r
            ModuleFile = PathClass(NormPath(Record[0]), GlobalData.gWorkspace, Arch=self._Arch)\r
            RecordList = self._RawData[MODEL_META_DATA_COMPONENT_SOURCE_OVERRIDE_PATH, self._Arch, None, ModuleId]\r
            if RecordList != []:\r
                SourceOverridePath = mws.join(GlobalData.gWorkspace, NormPath(RecordList[0][0]))\r
\r
                # Check if the source override path exists\r
                if not os.path.isdir(SourceOverridePath):\r
                    EdkLogger.error('build', FILE_NOT_FOUND, Message='Source override path does not exist:', File=self.MetaFile, ExtraData=SourceOverridePath, Line=LineNo)\r
\r
                # Add to GlobalData Variables\r
                GlobalData.gOverrideDir[ModuleFile.Key] = SourceOverridePath\r
\r
    ## Get current effective macros\r
    def _GetMacros(self):\r
        if self.__Macros is None:\r
            self.__Macros = {}\r
            self.__Macros.update(GlobalData.gPlatformDefines)\r
            self.__Macros.update(GlobalData.gGlobalDefines)\r
            self.__Macros.update(GlobalData.gCommandLineDefines)\r
        return self.__Macros\r
\r
    ## Get architecture\r
    def _GetArch(self):\r
        return self._Arch\r
\r
    ## Set architecture\r
    #\r
    #   Changing the default ARCH to another may affect all other information\r
    # because all information in a platform may be ARCH-related. That's\r
    # why we need to clear all internal used members, in order to cause all\r
    # information to be re-retrieved.\r
    #\r
    #   @param  Value   The value of ARCH\r
    #\r
    def _SetArch(self, Value):\r
        if self._Arch == Value:\r
            return\r
        self._Arch = Value\r
        self._Clear()\r
\r
    ## Retrieve all information in [Defines] section\r
    #\r
    #   (Retriving all [Defines] information in one-shot is just to save time.)\r
    #\r
    def _GetHeaderInfo(self):\r
        RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch]\r
        for Record in RecordList:\r
            Name = Record[1]\r
            # items defined _PROPERTY_ don't need additional processing\r
\r
            # some special items in [Defines] section need special treatment\r
            if Name == TAB_DSC_DEFINES_OUTPUT_DIRECTORY:\r
                self._OutputDirectory = NormPath(Record[2], self._Macros)\r
                if ' ' in self._OutputDirectory:\r
                    EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "No space is allowed in OUTPUT_DIRECTORY",\r
                                    File=self.MetaFile, Line=Record[-1],\r
                                    ExtraData=self._OutputDirectory)\r
            elif Name == TAB_DSC_DEFINES_FLASH_DEFINITION:\r
                self._FlashDefinition = PathClass(NormPath(Record[2], self._Macros), GlobalData.gWorkspace)\r
                ErrorCode, ErrorInfo = self._FlashDefinition.Validate('.fdf')\r
                if ErrorCode != 0:\r
                    EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=Record[-1],\r
                                    ExtraData=ErrorInfo)\r
            elif Name == TAB_DSC_PREBUILD:\r
                PrebuildValue = Record[2]\r
                if Record[2][0] == '"':\r
                    if Record[2][-1] != '"':\r
                        EdkLogger.error('build', FORMAT_INVALID, 'Missing double quotes in the end of %s statement.' % TAB_DSC_PREBUILD,\r
                                    File=self.MetaFile, Line=Record[-1])\r
                    PrebuildValue = Record[2][1:-1]\r
                self._Prebuild = PrebuildValue\r
            elif Name == TAB_DSC_POSTBUILD:\r
                PostbuildValue = Record[2]\r
                if Record[2][0] == '"':\r
                    if Record[2][-1] != '"':\r
                        EdkLogger.error('build', FORMAT_INVALID, 'Missing double quotes in the end of %s statement.' % TAB_DSC_POSTBUILD,\r
                                    File=self.MetaFile, Line=Record[-1])\r
                    PostbuildValue = Record[2][1:-1]\r
                self._Postbuild = PostbuildValue\r
            elif Name == TAB_DSC_DEFINES_SUPPORTED_ARCHITECTURES:\r
                self._SupArchList = GetSplitValueList(Record[2], TAB_VALUE_SPLIT)\r
            elif Name == TAB_DSC_DEFINES_BUILD_TARGETS:\r
                self._BuildTargets = GetSplitValueList(Record[2])\r
            elif Name == TAB_DSC_DEFINES_SKUID_IDENTIFIER:\r
                if self._SkuName is None:\r
                    self._SkuName = Record[2]\r
                if GlobalData.gSKUID_CMD:\r
                    self._SkuName = GlobalData.gSKUID_CMD\r
            elif Name == TAB_DSC_DEFINES_PCD_INFO_GENERATION:\r
                self._PcdInfoFlag = Record[2]\r
            elif Name == TAB_DSC_DEFINES_PCD_VAR_CHECK_GENERATION:\r
                self._VarCheckFlag = Record[2]\r
            elif Name == TAB_FIX_LOAD_TOP_MEMORY_ADDRESS:\r
                try:\r
                    self._LoadFixAddress = int (Record[2], 0)\r
                except:\r
                    EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS %s is not valid dec or hex string" % (Record[2]))\r
            elif Name == TAB_DSC_DEFINES_RFC_LANGUAGES:\r
                if not Record[2] or Record[2][0] != '"' or Record[2][-1] != '"' or len(Record[2]) == 1:\r
                    EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'language code for RFC_LANGUAGES must have double quotes around it, for example: RFC_LANGUAGES = "en-us;zh-hans"',\r
                                    File=self.MetaFile, Line=Record[-1])\r
                LanguageCodes = Record[2][1:-1]\r
                if not LanguageCodes:\r
                    EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'one or more RFC4646 format language code must be provided for RFC_LANGUAGES statement',\r
                                    File=self.MetaFile, Line=Record[-1])\r
                LanguageList = GetSplitValueList(LanguageCodes, TAB_SEMI_COLON_SPLIT)\r
                # check whether there is empty entries in the list\r
                if None in LanguageList:\r
                    EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'one or more empty language code is in RFC_LANGUAGES statement',\r
                                    File=self.MetaFile, Line=Record[-1])\r
                self._RFCLanguages = LanguageList\r
            elif Name == TAB_DSC_DEFINES_ISO_LANGUAGES:\r
                if not Record[2] or Record[2][0] != '"' or Record[2][-1] != '"' or len(Record[2]) == 1:\r
                    EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'language code for ISO_LANGUAGES must have double quotes around it, for example: ISO_LANGUAGES = "engchn"',\r
                                    File=self.MetaFile, Line=Record[-1])\r
                LanguageCodes = Record[2][1:-1]\r
                if not LanguageCodes:\r
                    EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'one or more ISO639-2 format language code must be provided for ISO_LANGUAGES statement',\r
                                    File=self.MetaFile, Line=Record[-1])\r
                if len(LanguageCodes) % 3:\r
                    EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'bad ISO639-2 format for ISO_LANGUAGES',\r
                                    File=self.MetaFile, Line=Record[-1])\r
                LanguageList = []\r
                for i in range(0, len(LanguageCodes), 3):\r
                    LanguageList.append(LanguageCodes[i:i + 3])\r
                self._ISOLanguages = LanguageList\r
            elif Name == TAB_DSC_DEFINES_VPD_TOOL_GUID:\r
                #\r
                # try to convert GUID to a real UUID value to see whether the GUID is format\r
                # for VPD_TOOL_GUID is correct.\r
                #\r
                try:\r
                    uuid.UUID(Record[2])\r
                except:\r
                    EdkLogger.error("build", FORMAT_INVALID, "Invalid GUID format for VPD_TOOL_GUID", File=self.MetaFile)\r
                self._VpdToolGuid = Record[2]\r
            elif Name in self:\r
                self[Name] = Record[2]\r
        # set _Header to non-None in order to avoid database re-querying\r
        self._Header = 'DUMMY'\r
\r
    ## Retrieve platform name\r
    def _GetPlatformName(self):\r
        if self._PlatformName is None:\r
            if self._Header is None:\r
                self._GetHeaderInfo()\r
            if self._PlatformName is None:\r
                EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No PLATFORM_NAME", File=self.MetaFile)\r
        return self._PlatformName\r
\r
    ## Retrieve file guid\r
    def _GetFileGuid(self):\r
        if self._Guid is None:\r
            if self._Header is None:\r
                self._GetHeaderInfo()\r
            if self._Guid is None:\r
                EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No PLATFORM_GUID", File=self.MetaFile)\r
        return self._Guid\r
\r
    ## Retrieve platform version\r
    def _GetVersion(self):\r
        if self._Version is None:\r
            if self._Header is None:\r
                self._GetHeaderInfo()\r
            if self._Version is None:\r
                EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No PLATFORM_VERSION", File=self.MetaFile)\r
        return self._Version\r
\r
    ## Retrieve platform description file version\r
    def _GetDscSpec(self):\r
        if self._DscSpecification is None:\r
            if self._Header is None:\r
                self._GetHeaderInfo()\r
            if self._DscSpecification is None:\r
                EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No DSC_SPECIFICATION", File=self.MetaFile)\r
        return self._DscSpecification\r
\r
    ## Retrieve OUTPUT_DIRECTORY\r
    def _GetOutpuDir(self):\r
        if self._OutputDirectory is None:\r
            if self._Header is None:\r
                self._GetHeaderInfo()\r
            if self._OutputDirectory is None:\r
                self._OutputDirectory = os.path.join("Build", self._PlatformName)\r
        return self._OutputDirectory\r
\r
    ## Retrieve SUPPORTED_ARCHITECTURES\r
    def _GetSupArch(self):\r
        if self._SupArchList is None:\r
            if self._Header is None:\r
                self._GetHeaderInfo()\r
            if self._SupArchList is None:\r
                EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No SUPPORTED_ARCHITECTURES", File=self.MetaFile)\r
        return self._SupArchList\r
\r
    ## Retrieve BUILD_TARGETS\r
    def _GetBuildTarget(self):\r
        if self._BuildTargets is None:\r
            if self._Header is None:\r
                self._GetHeaderInfo()\r
            if self._BuildTargets is None:\r
                EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No BUILD_TARGETS", File=self.MetaFile)\r
        return self._BuildTargets\r
\r
    def _GetPcdInfoFlag(self):\r
        if self._PcdInfoFlag is None or self._PcdInfoFlag.upper() == 'FALSE':\r
            return False\r
        elif self._PcdInfoFlag.upper() == 'TRUE':\r
            return True\r
        else:\r
            return False\r
    def _GetVarCheckFlag(self):\r
        if self._VarCheckFlag is None or self._VarCheckFlag.upper() == 'FALSE':\r
            return False\r
        elif self._VarCheckFlag.upper() == 'TRUE':\r
            return True\r
        else:\r
            return False\r
\r
    # # Retrieve SKUID_IDENTIFIER\r
    def _GetSkuName(self):\r
        if self._SkuName is None:\r
            if self._Header is None:\r
                self._GetHeaderInfo()\r
            if self._SkuName is None:\r
                self._SkuName = TAB_DEFAULT\r
        return self._SkuName\r
\r
    ## Override SKUID_IDENTIFIER\r
    def _SetSkuName(self, Value):\r
        self._SkuName = Value\r
\r
    def _GetFdfFile(self):\r
        if self._FlashDefinition is None:\r
            if self._Header is None:\r
                self._GetHeaderInfo()\r
            if self._FlashDefinition is None:\r
                self._FlashDefinition = ''\r
        return self._FlashDefinition\r
\r
    def _GetPrebuild(self):\r
        if self._Prebuild is None:\r
            if self._Header is None:\r
                self._GetHeaderInfo()\r
            if self._Prebuild is None:\r
                self._Prebuild = ''\r
        return self._Prebuild\r
\r
    def _GetPostbuild(self):\r
        if self._Postbuild is None:\r
            if self._Header is None:\r
                self._GetHeaderInfo()\r
            if self._Postbuild is None:\r
                self._Postbuild = ''\r
        return self._Postbuild\r
\r
    ## Retrieve FLASH_DEFINITION\r
    def _GetBuildNumber(self):\r
        if self._BuildNumber is None:\r
            if self._Header is None:\r
                self._GetHeaderInfo()\r
            if self._BuildNumber is None:\r
                self._BuildNumber = ''\r
        return self._BuildNumber\r
\r
    ## Retrieve MAKEFILE_NAME\r
    def _GetMakefileName(self):\r
        if self._MakefileName is None:\r
            if self._Header is None:\r
                self._GetHeaderInfo()\r
            if self._MakefileName is None:\r
                self._MakefileName = ''\r
        return self._MakefileName\r
\r
    ## Retrieve BsBaseAddress\r
    def _GetBsBaseAddress(self):\r
        if self._BsBaseAddress is None:\r
            if self._Header is None:\r
                self._GetHeaderInfo()\r
            if self._BsBaseAddress is None:\r
                self._BsBaseAddress = ''\r
        return self._BsBaseAddress\r
\r
    ## Retrieve RtBaseAddress\r
    def _GetRtBaseAddress(self):\r
        if self._RtBaseAddress is None:\r
            if self._Header is None:\r
                self._GetHeaderInfo()\r
            if self._RtBaseAddress is None:\r
                self._RtBaseAddress = ''\r
        return self._RtBaseAddress\r
\r
    ## Retrieve the top address for the load fix address\r
    def _GetLoadFixAddress(self):\r
        if self._LoadFixAddress is None:\r
            if self._Header is None:\r
                self._GetHeaderInfo()\r
\r
            if self._LoadFixAddress is None:\r
                self._LoadFixAddress = self._Macros.get(TAB_FIX_LOAD_TOP_MEMORY_ADDRESS, '0')\r
\r
            try:\r
                self._LoadFixAddress = int (self._LoadFixAddress, 0)\r
            except:\r
                EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS %s is not valid dec or hex string" % (self._LoadFixAddress))\r
\r
        #\r
        # If command line defined, should override the value in DSC file.\r
        #\r
        if 'FIX_LOAD_TOP_MEMORY_ADDRESS' in GlobalData.gCommandLineDefines:\r
            try:\r
                self._LoadFixAddress = int(GlobalData.gCommandLineDefines['FIX_LOAD_TOP_MEMORY_ADDRESS'], 0)\r
            except:\r
                EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS %s is not valid dec or hex string" % (GlobalData.gCommandLineDefines['FIX_LOAD_TOP_MEMORY_ADDRESS']))\r
\r
        if self._LoadFixAddress < 0:\r
            EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS is set to the invalid negative value 0x%x" % (self._LoadFixAddress))\r
        if self._LoadFixAddress != 0xFFFFFFFFFFFFFFFF and self._LoadFixAddress % 0x1000 != 0:\r
            EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS is set to the invalid unaligned 4K value 0x%x" % (self._LoadFixAddress))\r
\r
        return self._LoadFixAddress\r
\r
    ## Retrieve RFCLanguage filter\r
    def _GetRFCLanguages(self):\r
        if self._RFCLanguages is None:\r
            if self._Header is None:\r
                self._GetHeaderInfo()\r
            if self._RFCLanguages is None:\r
                self._RFCLanguages = []\r
        return self._RFCLanguages\r
\r
    ## Retrieve ISOLanguage filter\r
    def _GetISOLanguages(self):\r
        if self._ISOLanguages is None:\r
            if self._Header is None:\r
                self._GetHeaderInfo()\r
            if self._ISOLanguages is None:\r
                self._ISOLanguages = []\r
        return self._ISOLanguages\r
    ## Retrieve the GUID string for VPD tool\r
    def _GetVpdToolGuid(self):\r
        if self._VpdToolGuid is None:\r
            if self._Header is None:\r
                self._GetHeaderInfo()\r
            if self._VpdToolGuid is None:\r
                self._VpdToolGuid = ''\r
        return self._VpdToolGuid\r
\r
    ## Retrieve [SkuIds] section information\r
    def _GetSkuIds(self):\r
        if self._SkuIds is None:\r
            self._SkuIds = OrderedDict()\r
            RecordList = self._RawData[MODEL_EFI_SKU_ID, self._Arch]\r
            for Record in RecordList:\r
                if not Record[0]:\r
                    EdkLogger.error('build', FORMAT_INVALID, 'No Sku ID number',\r
                                    File=self.MetaFile, Line=Record[-1])\r
                if not Record[1]:\r
                    EdkLogger.error('build', FORMAT_INVALID, 'No Sku ID name',\r
                                    File=self.MetaFile, Line=Record[-1])\r
                if not Pattern.match(Record[0]) and not HexPattern.match(Record[0]):\r
                    EdkLogger.error('build', FORMAT_INVALID, "The format of the Sku ID number is invalid. It only support Integer and HexNumber",\r
                                    File=self.MetaFile, Line=Record[-1])\r
                if not IsValidWord(Record[1]):\r
                    EdkLogger.error('build', FORMAT_INVALID, "The format of the Sku ID name is invalid. The correct format is '(a-zA-Z0-9_)(a-zA-Z0-9_-.)*'",\r
                                    File=self.MetaFile, Line=Record[-1])\r
                self._SkuIds[Record[1].upper()] = (str(DscBuildData.ToInt(Record[0])), Record[1].upper(), Record[2].upper())\r
            if TAB_DEFAULT not in self._SkuIds:\r
                self._SkuIds[TAB_DEFAULT] = ("0", TAB_DEFAULT, TAB_DEFAULT)\r
            if TAB_COMMON not in self._SkuIds:\r
                self._SkuIds[TAB_COMMON] = ("0", TAB_DEFAULT, TAB_DEFAULT)\r
        return self._SkuIds\r
\r
    @staticmethod\r
    def ToInt(intstr):\r
        return int(intstr, 16) if intstr.upper().startswith("0X") else int(intstr)\r
\r
    def _GetDefaultStores(self):\r
        if self.DefaultStores is None:\r
            self.DefaultStores = OrderedDict()\r
            RecordList = self._RawData[MODEL_EFI_DEFAULT_STORES, self._Arch]\r
            for Record in RecordList:\r
                if not Record[0]:\r
                    EdkLogger.error('build', FORMAT_INVALID, 'No DefaultStores ID number',\r
                                    File=self.MetaFile, Line=Record[-1])\r
                if not Record[1]:\r
                    EdkLogger.error('build', FORMAT_INVALID, 'No DefaultStores ID name',\r
                                    File=self.MetaFile, Line=Record[-1])\r
                if not Pattern.match(Record[0]) and not HexPattern.match(Record[0]):\r
                    EdkLogger.error('build', FORMAT_INVALID, "The format of the DefaultStores ID number is invalid. It only support Integer and HexNumber",\r
                                    File=self.MetaFile, Line=Record[-1])\r
                if not IsValidWord(Record[1]):\r
                    EdkLogger.error('build', FORMAT_INVALID, "The format of the DefaultStores ID name is invalid. The correct format is '(a-zA-Z0-9_)(a-zA-Z0-9_-.)*'",\r
                                    File=self.MetaFile, Line=Record[-1])\r
                self.DefaultStores[Record[1].upper()] = (DscBuildData.ToInt(Record[0]), Record[1].upper())\r
            if TAB_DEFAULT_STORES_DEFAULT not in self.DefaultStores:\r
                self.DefaultStores[TAB_DEFAULT_STORES_DEFAULT] = (0, TAB_DEFAULT_STORES_DEFAULT)\r
            GlobalData.gDefaultStores = sorted(self.DefaultStores.keys())\r
        return self.DefaultStores\r
\r
    ## Retrieve [Components] section information\r
    def _GetModules(self):\r
        if self._Modules is not None:\r
            return self._Modules\r
\r
        self._Modules = OrderedDict()\r
        RecordList = self._RawData[MODEL_META_DATA_COMPONENT, self._Arch]\r
        Macros = self._Macros\r
        Macros["EDK_SOURCE"] = GlobalData.gEcpSource\r
        for Record in RecordList:\r
            DuplicatedFile = False\r
\r
            ModuleFile = PathClass(NormPath(Record[0], Macros), GlobalData.gWorkspace, Arch=self._Arch)\r
            ModuleId = Record[6]\r
            LineNo = Record[7]\r
\r
            # check the file validation\r
            ErrorCode, ErrorInfo = ModuleFile.Validate('.inf')\r
            if ErrorCode != 0:\r
                EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,\r
                                ExtraData=ErrorInfo)\r
            # Check duplication\r
            # If arch is COMMON, no duplicate module is checked since all modules in all component sections are selected\r
            if self._Arch != TAB_ARCH_COMMON and ModuleFile in self._Modules:\r
                DuplicatedFile = True\r
\r
            Module = ModuleBuildClassObject()\r
            Module.MetaFile = ModuleFile\r
\r
            # get module private library instance\r
            RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch, None, ModuleId]\r
            for Record in RecordList:\r
                LibraryClass = Record[0]\r
                LibraryPath = PathClass(NormPath(Record[1], Macros), GlobalData.gWorkspace, Arch=self._Arch)\r
                LineNo = Record[-1]\r
\r
                # check the file validation\r
                ErrorCode, ErrorInfo = LibraryPath.Validate('.inf')\r
                if ErrorCode != 0:\r
                    EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,\r
                                    ExtraData=ErrorInfo)\r
\r
                if LibraryClass == '' or LibraryClass == 'NULL':\r
                    self._NullLibraryNumber += 1\r
                    LibraryClass = 'NULL%d' % self._NullLibraryNumber\r
                    EdkLogger.verbose("Found forced library for %s\n\t%s [%s]" % (ModuleFile, LibraryPath, LibraryClass))\r
                Module.LibraryClasses[LibraryClass] = LibraryPath\r
                if LibraryPath not in self.LibraryInstances:\r
                    self.LibraryInstances.append(LibraryPath)\r
\r
            # get module private PCD setting\r
            for Type in [MODEL_PCD_FIXED_AT_BUILD, MODEL_PCD_PATCHABLE_IN_MODULE, \\r
                         MODEL_PCD_FEATURE_FLAG, MODEL_PCD_DYNAMIC, MODEL_PCD_DYNAMIC_EX]:\r
                RecordList = self._RawData[Type, self._Arch, None, ModuleId]\r
                for TokenSpaceGuid, PcdCName, Setting, Dummy1, Dummy2, Dummy3, Dummy4, Dummy5 in RecordList:\r
                    TokenList = GetSplitValueList(Setting)\r
                    DefaultValue = TokenList[0]\r
                    # the format is PcdName| Value | VOID* | MaxDatumSize\r
                    if len(TokenList) > 2:\r
                        MaxDatumSize = TokenList[2]\r
                    else:\r
                        MaxDatumSize = ''\r
                    TypeString = self._PCD_TYPE_STRING_[Type]\r
                    Pcd = PcdClassObject(\r
                            PcdCName,\r
                            TokenSpaceGuid,\r
                            TypeString,\r
                            '',\r
                            DefaultValue,\r
                            '',\r
                            MaxDatumSize,\r
                            {},\r
                            False,\r
                            None\r
                            )\r
                    Module.Pcds[PcdCName, TokenSpaceGuid] = Pcd\r
\r
            # get module private build options\r
            RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, self._Arch, None, ModuleId]\r
            for ToolChainFamily, ToolChain, Option, Dummy1, Dummy2, Dummy3, Dummy4, Dummy5 in RecordList:\r
                if (ToolChainFamily, ToolChain) not in Module.BuildOptions:\r
                    Module.BuildOptions[ToolChainFamily, ToolChain] = Option\r
                else:\r
                    OptionString = Module.BuildOptions[ToolChainFamily, ToolChain]\r
                    Module.BuildOptions[ToolChainFamily, ToolChain] = OptionString + " " + Option\r
\r
            RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch, None, ModuleId]\r
            if DuplicatedFile and not RecordList:\r
                EdkLogger.error('build', FILE_DUPLICATED, File=self.MetaFile, ExtraData=str(ModuleFile), Line=LineNo)\r
            if RecordList:\r
                if len(RecordList) != 1:\r
                    EdkLogger.error('build', OPTION_UNKNOWN, 'Only FILE_GUID can be listed in <Defines> section.',\r
                                    File=self.MetaFile, ExtraData=str(ModuleFile), Line=LineNo)\r
                ModuleFile = ProcessDuplicatedInf(ModuleFile, RecordList[0][2], GlobalData.gWorkspace)\r
                ModuleFile.Arch = self._Arch\r
\r
            self._Modules[ModuleFile] = Module\r
        return self._Modules\r
\r
    ## Retrieve all possible library instances used in this platform\r
    def _GetLibraryInstances(self):\r
        if self._LibraryInstances is None:\r
            self._GetLibraryClasses()\r
        return self._LibraryInstances\r
\r
    ## Retrieve [LibraryClasses] information\r
    def _GetLibraryClasses(self):\r
        if self._LibraryClasses is None:\r
            self._LibraryInstances = []\r
            #\r
            # tdict is a special dict kind of type, used for selecting correct\r
            # library instance for given library class and module type\r
            #\r
            LibraryClassDict = tdict(True, 3)\r
            # track all library class names\r
            LibraryClassSet = set()\r
            RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch, None, -1]\r
            Macros = self._Macros\r
            for Record in RecordList:\r
                LibraryClass, LibraryInstance, Dummy, Arch, ModuleType, Dummy, Dummy, LineNo = Record\r
                if LibraryClass == '' or LibraryClass == 'NULL':\r
                    self._NullLibraryNumber += 1\r
                    LibraryClass = 'NULL%d' % self._NullLibraryNumber\r
                    EdkLogger.verbose("Found forced library for arch=%s\n\t%s [%s]" % (Arch, LibraryInstance, LibraryClass))\r
                LibraryClassSet.add(LibraryClass)\r
                LibraryInstance = PathClass(NormPath(LibraryInstance, Macros), GlobalData.gWorkspace, Arch=self._Arch)\r
                # check the file validation\r
                ErrorCode, ErrorInfo = LibraryInstance.Validate('.inf')\r
                if ErrorCode != 0:\r
                    EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,\r
                                    ExtraData=ErrorInfo)\r
\r
                if ModuleType != TAB_COMMON and ModuleType not in SUP_MODULE_LIST:\r
                    EdkLogger.error('build', OPTION_UNKNOWN, "Unknown module type [%s]" % ModuleType,\r
                                    File=self.MetaFile, ExtraData=LibraryInstance, Line=LineNo)\r
                LibraryClassDict[Arch, ModuleType, LibraryClass] = LibraryInstance\r
                if LibraryInstance not in self._LibraryInstances:\r
                    self._LibraryInstances.append(LibraryInstance)\r
\r
            # resolve the specific library instance for each class and each module type\r
            self._LibraryClasses = tdict(True)\r
            for LibraryClass in LibraryClassSet:\r
                # try all possible module types\r
                for ModuleType in SUP_MODULE_LIST:\r
                    LibraryInstance = LibraryClassDict[self._Arch, ModuleType, LibraryClass]\r
                    if LibraryInstance is None:\r
                        continue\r
                    self._LibraryClasses[LibraryClass, ModuleType] = LibraryInstance\r
\r
            # for Edk style library instances, which are listed in different section\r
            Macros["EDK_SOURCE"] = GlobalData.gEcpSource\r
            RecordList = self._RawData[MODEL_EFI_LIBRARY_INSTANCE, self._Arch]\r
            for Record in RecordList:\r
                File = PathClass(NormPath(Record[0], Macros), GlobalData.gWorkspace, Arch=self._Arch)\r
                LineNo = Record[-1]\r
                # check the file validation\r
                ErrorCode, ErrorInfo = File.Validate('.inf')\r
                if ErrorCode != 0:\r
                    EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,\r
                                    ExtraData=ErrorInfo)\r
                if File not in self._LibraryInstances:\r
                    self._LibraryInstances.append(File)\r
                #\r
                # we need the module name as the library class name, so we have\r
                # to parse it here. (self._Bdb[] will trigger a file parse if it\r
                # hasn't been parsed)\r
                #\r
                Library = self._Bdb[File, self._Arch, self._Target, self._Toolchain]\r
                self._LibraryClasses[Library.BaseName, ':dummy:'] = Library\r
        return self._LibraryClasses\r
\r
    def _ValidatePcd(self, PcdCName, TokenSpaceGuid, Setting, PcdType, LineNo):\r
        if self._DecPcds is None:\r
\r
            FdfInfList = []\r
            if GlobalData.gFdfParser:\r
                FdfInfList = GlobalData.gFdfParser.Profile.InfList\r
\r
            PkgSet = set()\r
            for Inf in FdfInfList:\r
                ModuleFile = PathClass(NormPath(Inf), GlobalData.gWorkspace, Arch=self._Arch)\r
                if ModuleFile in self._Modules:\r
                    continue\r
                ModuleData = self._Bdb[ModuleFile, self._Arch, self._Target, self._Toolchain]\r
                PkgSet.update(ModuleData.Packages)\r
\r
            self._DecPcds, self._GuidDict = GetDeclaredPcd(self, self._Bdb, self._Arch, self._Target, self._Toolchain, PkgSet)\r
            self._GuidDict.update(GlobalData.gPlatformPcds)\r
\r
        if (PcdCName, TokenSpaceGuid) not in self._DecPcds:\r
            EdkLogger.error('build', PARSER_ERROR,\r
                            "Pcd (%s.%s) defined in DSC is not declared in DEC files. Arch: ['%s']" % (TokenSpaceGuid, PcdCName, self._Arch),\r
                            File=self.MetaFile, Line=LineNo)\r
        ValueList, IsValid, Index = AnalyzeDscPcd(Setting, PcdType, self._DecPcds[PcdCName, TokenSpaceGuid].DatumType)\r
        if not IsValid:\r
            if PcdType not in [MODEL_PCD_FEATURE_FLAG, MODEL_PCD_FIXED_AT_BUILD]:\r
                EdkLogger.error('build', FORMAT_INVALID, "Pcd format incorrect.", File=self.MetaFile, Line=LineNo,\r
                                ExtraData="%s.%s|%s" % (TokenSpaceGuid, PcdCName, Setting))\r
            else:\r
                if ValueList[2] == '-1':\r
                    EdkLogger.error('build', FORMAT_INVALID, "Pcd format incorrect.", File=self.MetaFile, Line=LineNo,\r
                                ExtraData="%s.%s|%s" % (TokenSpaceGuid, PcdCName, Setting))\r
        if ValueList[Index]:\r
            DatumType = self._DecPcds[PcdCName, TokenSpaceGuid].DatumType\r
            try:\r
                ValueList[Index] = ValueExpressionEx(ValueList[Index], DatumType, self._GuidDict)(True)\r
            except BadExpression as Value:\r
                EdkLogger.error('Parser', FORMAT_INVALID, Value, File=self.MetaFile, Line=LineNo,\r
                                ExtraData="PCD [%s.%s] Value \"%s\" " % (\r
                                TokenSpaceGuid, PcdCName, ValueList[Index]))\r
            except EvaluationException as Excpt:\r
                if hasattr(Excpt, 'Pcd'):\r
                    if Excpt.Pcd in GlobalData.gPlatformOtherPcds:\r
                        EdkLogger.error('Parser', FORMAT_INVALID, "Cannot use this PCD (%s) in an expression as"\r
                                        " it must be defined in a [PcdsFixedAtBuild] or [PcdsFeatureFlag] section"\r
                                        " of the DSC file" % Excpt.Pcd,\r
                                        File=self.MetaFile, Line=LineNo)\r
                    else:\r
                        EdkLogger.error('Parser', FORMAT_INVALID, "PCD (%s) is not defined in DSC file" % Excpt.Pcd,\r
                                        File=self.MetaFile, Line=LineNo)\r
                else:\r
                    EdkLogger.error('Parser', FORMAT_INVALID, "Invalid expression: %s" % str(Excpt),\r
                                    File=self.MetaFile, Line=LineNo)\r
\r
        if ValueList[Index]:\r
            Valid, ErrStr = CheckPcdDatum(self._DecPcds[PcdCName, TokenSpaceGuid].DatumType, ValueList[Index])\r
            if not Valid:\r
                EdkLogger.error('build', FORMAT_INVALID, ErrStr, File=self.MetaFile, Line=LineNo,\r
                                ExtraData="%s.%s" % (TokenSpaceGuid, PcdCName))\r
            if PcdType in (MODEL_PCD_DYNAMIC_DEFAULT, MODEL_PCD_DYNAMIC_EX_DEFAULT):\r
                if self._DecPcds[PcdCName, TokenSpaceGuid].DatumType.strip() != ValueList[1].strip():\r
                    EdkLogger.error('build', FORMAT_INVALID, "Pcd datumtype used in DSC file is not the same as its declaration in DEC file.", File=self.MetaFile, Line=LineNo,\r
                                ExtraData="%s.%s|%s" % (TokenSpaceGuid, PcdCName, Setting))\r
        if (TokenSpaceGuid + '.' + PcdCName) in GlobalData.gPlatformPcds:\r
            if GlobalData.gPlatformPcds[TokenSpaceGuid + '.' + PcdCName] != ValueList[Index]:\r
                GlobalData.gPlatformPcds[TokenSpaceGuid + '.' + PcdCName] = ValueList[Index]\r
        return ValueList\r
\r
    def _FilterPcdBySkuUsage(self, Pcds):\r
        available_sku = self.SkuIdMgr.AvailableSkuIdSet\r
        sku_usage = self.SkuIdMgr.SkuUsageType\r
        if sku_usage == SkuClass.SINGLE:\r
            for pcdname in Pcds:\r
                pcd = Pcds[pcdname]\r
                Pcds[pcdname].SkuInfoList = {TAB_DEFAULT:pcd.SkuInfoList[skuid] for skuid in pcd.SkuInfoList if skuid in available_sku}\r
                if type(pcd) is StructurePcd and pcd.SkuOverrideValues:\r
                    Pcds[pcdname].SkuOverrideValues = {TAB_DEFAULT:pcd.SkuOverrideValues[skuid] for skuid in pcd.SkuOverrideValues if skuid in available_sku}\r
        else:\r
            for pcdname in Pcds:\r
                pcd = Pcds[pcdname]\r
                Pcds[pcdname].SkuInfoList = {skuid:pcd.SkuInfoList[skuid] for skuid in pcd.SkuInfoList if skuid in available_sku}\r
                if type(pcd) is StructurePcd and pcd.SkuOverrideValues:\r
                    Pcds[pcdname].SkuOverrideValues = {skuid:pcd.SkuOverrideValues[skuid] for skuid in pcd.SkuOverrideValues if skuid in available_sku}\r
        return Pcds\r
    def CompleteHiiPcdsDefaultStores(self, Pcds):\r
        HiiPcd = [Pcds[pcd] for pcd in Pcds if Pcds[pcd].Type in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]]\r
        DefaultStoreMgr = DefaultStore(self.DefaultStores)\r
        for pcd in HiiPcd:\r
            for skuid in pcd.SkuInfoList:\r
                skuobj = pcd.SkuInfoList.get(skuid)\r
                if TAB_DEFAULT_STORES_DEFAULT not in skuobj.DefaultStoreDict:\r
                    PcdDefaultStoreSet = set(defaultstorename  for defaultstorename in skuobj.DefaultStoreDict)\r
                    mindefaultstorename = DefaultStoreMgr.GetMin(PcdDefaultStoreSet)\r
                    skuobj.DefaultStoreDict[TAB_DEFAULT_STORES_DEFAULT] = copy.deepcopy(skuobj.DefaultStoreDict[mindefaultstorename])\r
        return Pcds\r
\r
    def RecoverCommandLinePcd(self):\r
        def UpdateCommandLineValue(pcd):\r
            if pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_FIXED_AT_BUILD],\r
                                        self._PCD_TYPE_STRING_[MODEL_PCD_PATCHABLE_IN_MODULE]]:\r
                pcd.PcdValueFromComm = pcd.DefaultValue\r
            elif pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:\r
                pcd.PcdValueFromComm = pcd.SkuInfoList.get(TAB_DEFAULT).HiiDefaultValue\r
            else:\r
                pcd.PcdValueFromComm = pcd.SkuInfoList.get(TAB_DEFAULT).DefaultValue\r
        for pcd in self._Pcds:\r
            if isinstance(self._Pcds[pcd], StructurePcd) and (self._Pcds[pcd].PcdValueFromComm or self._Pcds[pcd].PcdFieldValueFromComm):\r
                UpdateCommandLineValue(self._Pcds[pcd])\r
\r
    def __ParsePcdFromCommandLine(self):\r
        if GlobalData.BuildOptionPcd:\r
            for i, pcd in enumerate(GlobalData.BuildOptionPcd):\r
                if type(pcd) is tuple:\r
                    continue\r
                (pcdname, pcdvalue) = pcd.split('=')\r
                if not pcdvalue:\r
                    EdkLogger.error('build', AUTOGEN_ERROR, "No Value specified for the PCD %s." % (pcdname))\r
                if '.' in pcdname:\r
                    (Name1, Name2) = pcdname.split('.', 1)\r
                    if "." in Name2:\r
                        (Name3, FieldName) = Name2.split(".", 1)\r
                        if ((Name3, Name1)) in self.DecPcds:\r
                            HasTokenSpace = True\r
                            TokenCName = Name3\r
                            TokenSpaceGuidCName = Name1\r
                        else:\r
                            FieldName = Name2\r
                            TokenCName = Name1\r
                            TokenSpaceGuidCName = ''\r
                            HasTokenSpace = False\r
                    else:\r
                        if ((Name2, Name1)) in self.DecPcds:\r
                            HasTokenSpace = True\r
                            TokenCName = Name2\r
                            TokenSpaceGuidCName = Name1\r
                            FieldName =""\r
                        else:\r
                            FieldName = Name2\r
                            TokenCName = Name1\r
                            TokenSpaceGuidCName = ''\r
                            HasTokenSpace = False\r
                else:\r
                    FieldName = ""\r
                    TokenCName = pcdname\r
                    TokenSpaceGuidCName = ''\r
                    HasTokenSpace = False\r
                TokenSpaceGuidCNameList = []\r
                FoundFlag = False\r
                PcdDatumType = ''\r
                DisplayName = TokenCName\r
                if FieldName:\r
                    DisplayName = TokenCName + '.' + FieldName\r
                if not HasTokenSpace:\r
                    for key in self.DecPcds:\r
                        PcdItem = self.DecPcds[key]\r
                        if TokenCName == PcdItem.TokenCName:\r
                            if not PcdItem.TokenSpaceGuidCName in TokenSpaceGuidCNameList:\r
                                if len (TokenSpaceGuidCNameList) < 1:\r
                                    TokenSpaceGuidCNameList.append(PcdItem.TokenSpaceGuidCName)\r
                                    TokenSpaceGuidCName = PcdItem.TokenSpaceGuidCName\r
                                    PcdDatumType = PcdItem.DatumType\r
                                    FoundFlag = True\r
                                else:\r
                                    EdkLogger.error(\r
                                            'build',\r
                                             AUTOGEN_ERROR,\r
                                            "The Pcd %s is found under multiple different TokenSpaceGuid: %s and %s." % (DisplayName, PcdItem.TokenSpaceGuidCName, TokenSpaceGuidCNameList[0])\r
                                            )\r
                else:\r
                    if (TokenCName, TokenSpaceGuidCName) in self.DecPcds:\r
                        PcdDatumType = self.DecPcds[(TokenCName, TokenSpaceGuidCName)].DatumType\r
                        FoundFlag = True\r
                if not FoundFlag:\r
                    if HasTokenSpace:\r
                        EdkLogger.error('build', AUTOGEN_ERROR, "The Pcd %s.%s is not found in the DEC file." % (TokenSpaceGuidCName, DisplayName))\r
                    else:\r
                        EdkLogger.error('build', AUTOGEN_ERROR, "The Pcd %s is not found in the DEC file." % (DisplayName))\r
                pcdvalue = pcdvalue.replace("\\\\\\'", '\\\\\\"').replace('\\\'', '\'').replace('\\\\\\"', "\\'")\r
                if FieldName:\r
                    pcdvalue = DscBuildData.HandleFlexiblePcd(TokenSpaceGuidCName, TokenCName, pcdvalue, PcdDatumType, self._GuidDict, FieldName)\r
                else:\r
                    pcdvalue = DscBuildData.HandleFlexiblePcd(TokenSpaceGuidCName, TokenCName, pcdvalue, PcdDatumType, self._GuidDict)\r
                    IsValid, Cause = CheckPcdDatum(PcdDatumType, pcdvalue)\r
                    if not IsValid:\r
                        EdkLogger.error("build", FORMAT_INVALID, Cause, ExtraData="%s.%s" % (TokenSpaceGuidCName, TokenCName))\r
                GlobalData.BuildOptionPcd[i] = (TokenSpaceGuidCName, TokenCName, FieldName, pcdvalue, ("build command options", 1))\r
\r
                for BuildData in self._Bdb._CACHE_.values():\r
                    if BuildData.MetaFile.Ext == '.dec' or BuildData.MetaFile.Ext == '.dsc':\r
                        continue\r
                    for key in BuildData.Pcds:\r
                        PcdItem = BuildData.Pcds[key]\r
                        if (TokenSpaceGuidCName, TokenCName) == (PcdItem.TokenSpaceGuidCName, PcdItem.TokenCName) and FieldName =="":\r
                            PcdItem.DefaultValue = pcdvalue\r
\r
    @staticmethod\r
    def HandleFlexiblePcd(TokenSpaceGuidCName, TokenCName, PcdValue, PcdDatumType, GuidDict, FieldName=''):\r
        if FieldName:\r
            IsArray = False\r
            TokenCName += '.' + FieldName\r
        if PcdValue.startswith('H'):\r
            if FieldName and IsFieldValueAnArray(PcdValue[1:]):\r
                PcdDatumType = TAB_VOID\r
                IsArray = True\r
            if FieldName and not IsArray:\r
                return PcdValue\r
            try:\r
                PcdValue = ValueExpressionEx(PcdValue[1:], PcdDatumType, GuidDict)(True)\r
            except BadExpression as Value:\r
                EdkLogger.error('Parser', FORMAT_INVALID, 'PCD [%s.%s] Value "%s",  %s' %\r
                                (TokenSpaceGuidCName, TokenCName, PcdValue, Value))\r
        elif PcdValue.startswith("L'") or PcdValue.startswith("'"):\r
            if FieldName and IsFieldValueAnArray(PcdValue):\r
                PcdDatumType = TAB_VOID\r
                IsArray = True\r
            if FieldName and not IsArray:\r
                return PcdValue\r
            try:\r
                PcdValue = ValueExpressionEx(PcdValue, PcdDatumType, GuidDict)(True)\r
            except BadExpression as Value:\r
                EdkLogger.error('Parser', FORMAT_INVALID, 'PCD [%s.%s] Value "%s",  %s' %\r
                                (TokenSpaceGuidCName, TokenCName, PcdValue, Value))\r
        elif PcdValue.startswith('L'):\r
            PcdValue = 'L"' + PcdValue[1:] + '"'\r
            if FieldName and IsFieldValueAnArray(PcdValue):\r
                PcdDatumType = TAB_VOID\r
                IsArray = True\r
            if FieldName and not IsArray:\r
                return PcdValue\r
            try:\r
                PcdValue = ValueExpressionEx(PcdValue, PcdDatumType, GuidDict)(True)\r
            except BadExpression as Value:\r
                EdkLogger.error('Parser', FORMAT_INVALID, 'PCD [%s.%s] Value "%s",  %s' %\r
                                (TokenSpaceGuidCName, TokenCName, PcdValue, Value))\r
        else:\r
            if PcdValue.upper() == 'FALSE':\r
                PcdValue = str(0)\r
            if PcdValue.upper() == 'TRUE':\r
                PcdValue = str(1)\r
            if not FieldName:\r
                if PcdDatumType not in TAB_PCD_NUMERIC_TYPES:\r
                    PcdValue = '"' + PcdValue + '"'\r
            else:\r
                IsArray = False\r
                Base = 10\r
                if PcdValue.upper().startswith('0X'):\r
                    Base = 16\r
                try:\r
                    Num = int(PcdValue, Base)\r
                except:\r
                    PcdValue = '"' + PcdValue + '"'\r
                if IsFieldValueAnArray(PcdValue):\r
                    PcdDatumType = TAB_VOID\r
                    IsArray = True\r
                if not IsArray:\r
                    return PcdValue\r
            try:\r
                PcdValue = ValueExpressionEx(PcdValue, PcdDatumType, GuidDict)(True)\r
            except BadExpression as Value:\r
                EdkLogger.error('Parser', FORMAT_INVALID, 'PCD [%s.%s] Value "%s",  %s' %\r
                                (TokenSpaceGuidCName, TokenCName, PcdValue, Value))\r
        return PcdValue\r
\r
    ## Retrieve all PCD settings in platform\r
    def _GetPcds(self):\r
        if self._Pcds is None:\r
            self._Pcds = OrderedDict()\r
            self.__ParsePcdFromCommandLine()\r
            self._Pcds.update(self._GetPcd(MODEL_PCD_FIXED_AT_BUILD))\r
            self._Pcds.update(self._GetPcd(MODEL_PCD_PATCHABLE_IN_MODULE))\r
            self._Pcds.update(self._GetPcd(MODEL_PCD_FEATURE_FLAG))\r
            self._Pcds.update(self._GetDynamicPcd(MODEL_PCD_DYNAMIC_DEFAULT))\r
            self._Pcds.update(self._GetDynamicHiiPcd(MODEL_PCD_DYNAMIC_HII))\r
            self._Pcds.update(self._GetDynamicVpdPcd(MODEL_PCD_DYNAMIC_VPD))\r
            self._Pcds.update(self._GetDynamicPcd(MODEL_PCD_DYNAMIC_EX_DEFAULT))\r
            self._Pcds.update(self._GetDynamicHiiPcd(MODEL_PCD_DYNAMIC_EX_HII))\r
            self._Pcds.update(self._GetDynamicVpdPcd(MODEL_PCD_DYNAMIC_EX_VPD))\r
\r
            self._Pcds = self.CompletePcdValues(self._Pcds)\r
            self._Pcds = self.OverrideByFdfCommOverAll(self._Pcds)\r
            self._Pcds = self.UpdateStructuredPcds(MODEL_PCD_TYPE_LIST, self._Pcds)\r
            self._Pcds = self.CompleteHiiPcdsDefaultStores(self._Pcds)\r
            self._Pcds = self._FilterPcdBySkuUsage(self._Pcds)\r
\r
            self.RecoverCommandLinePcd()\r
        return self._Pcds\r
\r
    ## Retrieve [BuildOptions]\r
    def _GetBuildOptions(self):\r
        if self._BuildOptions is None:\r
            self._BuildOptions = OrderedDict()\r
            #\r
            # Retrieve build option for EDKII and EDK style module\r
            #\r
            for CodeBase in (EDKII_NAME, EDK_NAME):\r
                RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, self._Arch, CodeBase]\r
                for ToolChainFamily, ToolChain, Option, Dummy1, Dummy2, Dummy3, Dummy4, Dummy5 in RecordList:\r
                    if Dummy3.upper() != TAB_COMMON:\r
                        continue\r
                    CurKey = (ToolChainFamily, ToolChain, CodeBase)\r
                    #\r
                    # Only flags can be appended\r
                    #\r
                    if CurKey not in self._BuildOptions or not ToolChain.endswith('_FLAGS') or Option.startswith('='):\r
                        self._BuildOptions[CurKey] = Option\r
                    else:\r
                        if ' ' + Option not in self._BuildOptions[CurKey]:\r
                            self._BuildOptions[CurKey] += ' ' + Option\r
        return self._BuildOptions\r
\r
    def GetBuildOptionsByModuleType(self, Edk, ModuleType):\r
        if self._ModuleTypeOptions is None:\r
            self._ModuleTypeOptions = OrderedDict()\r
        if (Edk, ModuleType) not in self._ModuleTypeOptions:\r
            options = OrderedDict()\r
            self._ModuleTypeOptions[Edk, ModuleType] = options\r
            DriverType = '%s.%s' % (Edk, ModuleType)\r
            CommonDriverType = '%s.%s' % (TAB_COMMON, ModuleType)\r
            RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, self._Arch]\r
            for ToolChainFamily, ToolChain, Option, Dummy1, Dummy2, Dummy3, Dummy4, Dummy5 in RecordList:\r
                Type = Dummy2 + '.' + Dummy3\r
                if Type.upper() == DriverType.upper() or Type.upper() == CommonDriverType.upper():\r
                    Key = (ToolChainFamily, ToolChain, Edk)\r
                    if Key not in options or not ToolChain.endswith('_FLAGS') or Option.startswith('='):\r
                        options[Key] = Option\r
                    else:\r
                        if ' ' + Option not in options[Key]:\r
                            options[Key] += ' ' + Option\r
        return self._ModuleTypeOptions[Edk, ModuleType]\r
\r
    @staticmethod\r
    def GetStructurePcdInfo(PcdSet):\r
        structure_pcd_data = defaultdict(list)\r
        for item in PcdSet:\r
            structure_pcd_data[(item[0], item[1])].append(item)\r
\r
        return structure_pcd_data\r
\r
    @staticmethod\r
    def OverrideByFdfComm(StruPcds):\r
        StructurePcdInCom = OrderedDict()\r
        for item in GlobalData.BuildOptionPcd:\r
            if len(item) == 5 and (item[1], item[0]) in StruPcds:\r
                StructurePcdInCom[(item[0], item[1], item[2] )] = (item[3], item[4])\r
        GlobalPcds = {(item[0], item[1]) for item in StructurePcdInCom}\r
        for Pcd in StruPcds.values():\r
            if (Pcd.TokenSpaceGuidCName, Pcd.TokenCName) not in GlobalPcds:\r
                continue\r
            FieldValues = OrderedDict()\r
            for item in StructurePcdInCom:\r
                if (Pcd.TokenSpaceGuidCName, Pcd.TokenCName) == (item[0], item[1]) and item[2]:\r
                    FieldValues[item[2]] = StructurePcdInCom[item]\r
            for field in FieldValues:\r
                if field not in Pcd.PcdFieldValueFromComm:\r
                    Pcd.PcdFieldValueFromComm[field] = ["", "", ""]\r
                Pcd.PcdFieldValueFromComm[field][0] = FieldValues[field][0]\r
                Pcd.PcdFieldValueFromComm[field][1] = FieldValues[field][1][0]\r
                Pcd.PcdFieldValueFromComm[field][2] = FieldValues[field][1][1]\r
        return StruPcds\r
\r
    def OverrideByFdfCommOverAll(self, AllPcds):\r
        def CheckStructureInComm(commpcds):\r
            if not commpcds:\r
                return False\r
            if len(commpcds[0]) == 5:\r
                return True\r
            return False\r
\r
        if CheckStructureInComm(GlobalData.BuildOptionPcd):\r
            StructurePcdInCom = {(item[0], item[1], item[2] ):(item[3], item[4]) for item in GlobalData.BuildOptionPcd } if GlobalData.BuildOptionPcd else {}\r
            NoFiledValues = {(item[0], item[1]):StructurePcdInCom[item] for item in StructurePcdInCom if not item[2]}\r
        else:\r
            NoFiledValues = {(item[0], item[1]):[item[2]] for item in GlobalData.BuildOptionPcd}\r
        for Guid, Name in NoFiledValues:\r
            if (Name, Guid) in AllPcds:\r
                Pcd = AllPcds.get((Name, Guid))\r
                if isinstance(self._DecPcds.get((Pcd.TokenCName, Pcd.TokenSpaceGuidCName), None), StructurePcd):\r
                    self._DecPcds.get((Pcd.TokenCName, Pcd.TokenSpaceGuidCName)).PcdValueFromComm = NoFiledValues[(Pcd.TokenSpaceGuidCName, Pcd.TokenCName)][0]\r
                else:\r
                    Pcd.PcdValueFromComm = NoFiledValues[(Pcd.TokenSpaceGuidCName, Pcd.TokenCName)][0]\r
                    Pcd.DefaultValue = NoFiledValues[(Pcd.TokenSpaceGuidCName, Pcd.TokenCName)][0]\r
                    for sku in Pcd.SkuInfoList:\r
                        SkuInfo = Pcd.SkuInfoList[sku]\r
                        if SkuInfo.DefaultValue:\r
                            SkuInfo.DefaultValue = NoFiledValues[(Pcd.TokenSpaceGuidCName, Pcd.TokenCName)][0]\r
                        else:\r
                            SkuInfo.HiiDefaultValue = NoFiledValues[(Pcd.TokenSpaceGuidCName, Pcd.TokenCName)][0]\r
                            for defaultstore in SkuInfo.DefaultStoreDict:\r
                                SkuInfo.DefaultStoreDict[defaultstore] = NoFiledValues[(Pcd.TokenSpaceGuidCName, Pcd.TokenCName)][0]\r
                    if Pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII]]:\r
                        if Pcd.DatumType == TAB_VOID:\r
                            if not Pcd.MaxDatumSize:\r
                                Pcd.MaxDatumSize = '0'\r
                            CurrentSize = int(Pcd.MaxDatumSize, 16) if Pcd.MaxDatumSize.upper().startswith("0X") else int(Pcd.MaxDatumSize)\r
                            OptionSize = len((StringToArray(Pcd.PcdValueFromComm)).split(","))\r
                            MaxSize = max(CurrentSize, OptionSize)\r
                            Pcd.MaxDatumSize = str(MaxSize)\r
            else:\r
                PcdInDec = self.DecPcds.get((Name, Guid))\r
                if PcdInDec:\r
                    PcdInDec.PcdValueFromComm = NoFiledValues[(Guid, Name)][0]\r
                    if PcdInDec.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_FIXED_AT_BUILD],\r
                                        self._PCD_TYPE_STRING_[MODEL_PCD_PATCHABLE_IN_MODULE],\r
                                        self._PCD_TYPE_STRING_[MODEL_PCD_FEATURE_FLAG]]:\r
                        self.Pcds[Name, Guid] = copy.deepcopy(PcdInDec)\r
                        self.Pcds[Name, Guid].DefaultValue = NoFiledValues[( Guid, Name)][0]\r
        return AllPcds\r
    def UpdateStructuredPcds(self, TypeList, AllPcds):\r
\r
        DynamicPcdType = [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_DEFAULT],\r
                        self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII],\r
                        self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_VPD],\r
                        self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_DEFAULT],\r
                        self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII],\r
                        self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_VPD]]\r
\r
        Pcds = AllPcds\r
        DefaultStoreMgr = DefaultStore(self.DefaultStores)\r
        SkuIds = self.SkuIdMgr.AvailableSkuIdSet\r
        SkuIds.update({TAB_DEFAULT:0})\r
        DefaultStores = {storename for pcdobj in AllPcds.values() for skuobj in pcdobj.SkuInfoList.values() for storename in skuobj.DefaultStoreDict}\r
\r
        S_PcdSet = []\r
        # Find out all possible PCD candidates for self._Arch\r
        RecordList = []\r
\r
        for Type in TypeList:\r
            RecordList.extend(self._RawData[Type, self._Arch])\r
\r
        for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, default_store, Dummy4, Dummy5 in RecordList:\r
            SkuName = SkuName.upper()\r
            default_store = default_store.upper()\r
            SkuName = TAB_DEFAULT if SkuName == TAB_COMMON else SkuName\r
            if SkuName not in SkuIds:\r
                continue\r
\r
            if SkuName in SkuIds and "." in TokenSpaceGuid:\r
                S_PcdSet.append([ TokenSpaceGuid.split(".")[0], TokenSpaceGuid.split(".")[1], PcdCName, SkuName, default_store, Dummy5, AnalyzePcdExpression(Setting)[0]])\r
\r
        # handle pcd value override\r
        StrPcdSet = DscBuildData.GetStructurePcdInfo(S_PcdSet)\r
        S_pcd_set = OrderedDict()\r
        for str_pcd in StrPcdSet:\r
            str_pcd_obj = Pcds.get((str_pcd[1], str_pcd[0]), None)\r
            str_pcd_dec = self._DecPcds.get((str_pcd[1], str_pcd[0]), None)\r
            if not isinstance (str_pcd_dec, StructurePcd):\r
                EdkLogger.error('build', PARSER_ERROR,\r
                            "Pcd (%s.%s) is not declared as Structure PCD in DEC files. Arch: ['%s']" % (str_pcd[0], str_pcd[1], self._Arch),\r
                            File=self.MetaFile, Line = StrPcdSet[str_pcd][0][5])\r
            if str_pcd_dec:\r
                str_pcd_obj_str = StructurePcd()\r
                str_pcd_obj_str.copy(str_pcd_dec)\r
                if str_pcd_obj:\r
                    str_pcd_obj_str.copy(str_pcd_obj)\r
                    if str_pcd_obj.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:\r
                        str_pcd_obj_str.DefaultFromDSC = {skuname:{defaultstore: str_pcd_obj.SkuInfoList[skuname].DefaultStoreDict.get(defaultstore, str_pcd_obj.SkuInfoList[skuname].HiiDefaultValue) for defaultstore in DefaultStores} for skuname in str_pcd_obj.SkuInfoList}\r
                    else:\r
                        str_pcd_obj_str.DefaultFromDSC = {skuname:{defaultstore: str_pcd_obj.SkuInfoList[skuname].DefaultStoreDict.get(defaultstore, str_pcd_obj.SkuInfoList[skuname].DefaultValue) for defaultstore in DefaultStores} for skuname in str_pcd_obj.SkuInfoList}\r
                for str_pcd_data in StrPcdSet[str_pcd]:\r
                    if str_pcd_data[3] in SkuIds:\r
                        str_pcd_obj_str.AddOverrideValue(str_pcd_data[2], str(str_pcd_data[6]), TAB_DEFAULT if str_pcd_data[3] == TAB_COMMON else str_pcd_data[3], TAB_DEFAULT_STORES_DEFAULT if str_pcd_data[4] == TAB_COMMON else str_pcd_data[4], self.MetaFile.File if self.WorkspaceDir not in self.MetaFile.File else self.MetaFile.File[len(self.WorkspaceDir) if self.WorkspaceDir.endswith(os.path.sep) else len(self.WorkspaceDir)+1:], LineNo=str_pcd_data[5])\r
                S_pcd_set[str_pcd[1], str_pcd[0]] = str_pcd_obj_str\r
            else:\r
                EdkLogger.error('build', PARSER_ERROR,\r
                            "Pcd (%s.%s) defined in DSC is not declared in DEC files. Arch: ['%s']" % (str_pcd[0], str_pcd[1], self._Arch),\r
                            File=self.MetaFile, Line = StrPcdSet[str_pcd][0][5])\r
        # Add the Structure PCD that only defined in DEC, don't have override in DSC file\r
        for Pcd in self.DecPcds:\r
            if type (self._DecPcds[Pcd]) is StructurePcd:\r
                if Pcd not in S_pcd_set:\r
                    str_pcd_obj_str = StructurePcd()\r
                    str_pcd_obj_str.copy(self._DecPcds[Pcd])\r
                    str_pcd_obj = Pcds.get(Pcd, None)\r
                    if str_pcd_obj:\r
                        str_pcd_obj_str.copy(str_pcd_obj)\r
                        if str_pcd_obj.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:\r
                            str_pcd_obj_str.DefaultFromDSC = {skuname:{defaultstore: str_pcd_obj.SkuInfoList[skuname].DefaultStoreDict.get(defaultstore, str_pcd_obj.SkuInfoList[skuname].HiiDefaultValue) for defaultstore in DefaultStores} for skuname in str_pcd_obj.SkuInfoList}\r
                        else:\r
                            str_pcd_obj_str.DefaultFromDSC = {skuname:{defaultstore: str_pcd_obj.SkuInfoList[skuname].DefaultStoreDict.get(defaultstore, str_pcd_obj.SkuInfoList[skuname].DefaultValue) for defaultstore in DefaultStores} for skuname in str_pcd_obj.SkuInfoList}\r
                    S_pcd_set[Pcd] = str_pcd_obj_str\r
        if S_pcd_set:\r
            GlobalData.gStructurePcd[self.Arch] = S_pcd_set\r
        for stru_pcd in S_pcd_set.values():\r
            for skuid in SkuIds:\r
                if skuid in stru_pcd.SkuOverrideValues:\r
                    continue\r
                nextskuid = self.SkuIdMgr.GetNextSkuId(skuid)\r
                NoDefault = False\r
                if skuid not in stru_pcd.SkuOverrideValues:\r
                    while nextskuid not in stru_pcd.SkuOverrideValues:\r
                        if nextskuid == TAB_DEFAULT:\r
                            NoDefault = True\r
                            break\r
                        nextskuid = self.SkuIdMgr.GetNextSkuId(nextskuid)\r
                    stru_pcd.SkuOverrideValues[skuid] = copy.deepcopy(stru_pcd.SkuOverrideValues[nextskuid]) if not NoDefault else copy.deepcopy({defaultstorename: stru_pcd.DefaultValues for defaultstorename in DefaultStores} if DefaultStores else {TAB_DEFAULT_STORES_DEFAULT:stru_pcd.DefaultValues})\r
                    if not NoDefault:\r
                        stru_pcd.ValueChain.add((skuid, ''))\r
            if stru_pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:\r
                for skuid in SkuIds:\r
                    nextskuid = skuid\r
                    NoDefault = False\r
                    if skuid not in stru_pcd.SkuOverrideValues:\r
                        while nextskuid not in stru_pcd.SkuOverrideValues:\r
                            if nextskuid == TAB_DEFAULT:\r
                                NoDefault = True\r
                                break\r
                            nextskuid = self.SkuIdMgr.GetNextSkuId(nextskuid)\r
                    if NoDefault:\r
                        continue\r
                    PcdDefaultStoreSet = set(defaultstorename  for defaultstorename in stru_pcd.SkuOverrideValues[nextskuid])\r
                    mindefaultstorename = DefaultStoreMgr.GetMin(PcdDefaultStoreSet)\r
\r
                    for defaultstoreid in DefaultStores:\r
                        if defaultstoreid not in stru_pcd.SkuOverrideValues[skuid]:\r
                            stru_pcd.SkuOverrideValues[skuid][defaultstoreid] = copy.deepcopy(stru_pcd.SkuOverrideValues[nextskuid][mindefaultstorename])\r
                            stru_pcd.ValueChain.add((skuid, defaultstoreid))\r
        S_pcd_set = DscBuildData.OverrideByFdfComm(S_pcd_set)\r
        Str_Pcd_Values = self.GenerateByteArrayValue(S_pcd_set)\r
        if Str_Pcd_Values:\r
            for (skuname, StoreName, PcdGuid, PcdName, PcdValue) in Str_Pcd_Values:\r
                str_pcd_obj = S_pcd_set.get((PcdName, PcdGuid))\r
                if str_pcd_obj is None:\r
                    print(PcdName, PcdGuid)\r
                    raise\r
                if str_pcd_obj.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII],\r
                                        self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:\r
                    if skuname not in str_pcd_obj.SkuInfoList:\r
                        str_pcd_obj.SkuInfoList[skuname] = SkuInfoClass(SkuIdName=skuname, SkuId=self.SkuIds[skuname][0], HiiDefaultValue=PcdValue, DefaultStore = {StoreName:PcdValue})\r
                    else:\r
                        str_pcd_obj.SkuInfoList[skuname].HiiDefaultValue = PcdValue\r
                        str_pcd_obj.SkuInfoList[skuname].DefaultStoreDict.update({StoreName:PcdValue})\r
                elif str_pcd_obj.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_FIXED_AT_BUILD],\r
                                        self._PCD_TYPE_STRING_[MODEL_PCD_PATCHABLE_IN_MODULE]]:\r
                    if skuname in (self.SkuIdMgr.SystemSkuId, TAB_DEFAULT, TAB_COMMON):\r
                        str_pcd_obj.DefaultValue = PcdValue\r
                else:\r
                    if skuname not in str_pcd_obj.SkuInfoList:\r
                        nextskuid = self.SkuIdMgr.GetNextSkuId(skuname)\r
                        NoDefault = False\r
                        while nextskuid not in str_pcd_obj.SkuInfoList:\r
                            if nextskuid == TAB_DEFAULT:\r
                                NoDefault = True\r
                                break\r
                            nextskuid = self.SkuIdMgr.GetNextSkuId(nextskuid)\r
                        str_pcd_obj.SkuInfoList[skuname] = copy.deepcopy(str_pcd_obj.SkuInfoList[nextskuid]) if not NoDefault else SkuInfoClass(SkuIdName=skuname, SkuId=self.SkuIds[skuname][0], DefaultValue=PcdValue)\r
                        str_pcd_obj.SkuInfoList[skuname].SkuId = self.SkuIds[skuname][0]\r
                        str_pcd_obj.SkuInfoList[skuname].SkuIdName = skuname\r
                    else:\r
                        str_pcd_obj.SkuInfoList[skuname].DefaultValue = PcdValue\r
            for str_pcd_obj in S_pcd_set.values():\r
                if str_pcd_obj.Type not in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII],\r
                                        self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:\r
                    continue\r
                PcdDefaultStoreSet = set(defaultstorename for skuobj in str_pcd_obj.SkuInfoList.values() for defaultstorename in skuobj.DefaultStoreDict)\r
                DefaultStoreObj = DefaultStore(self._GetDefaultStores())\r
                mindefaultstorename = DefaultStoreObj.GetMin(PcdDefaultStoreSet)\r
                str_pcd_obj.SkuInfoList[self.SkuIdMgr.SystemSkuId].HiiDefaultValue = str_pcd_obj.SkuInfoList[self.SkuIdMgr.SystemSkuId].DefaultStoreDict[mindefaultstorename]\r
\r
            for str_pcd_obj in S_pcd_set.values():\r
\r
                str_pcd_obj.MaxDatumSize = self.GetStructurePcdMaxSize(str_pcd_obj)\r
                Pcds[str_pcd_obj.TokenCName, str_pcd_obj.TokenSpaceGuidCName] = str_pcd_obj\r
\r
            for pcdkey in Pcds:\r
                pcd = Pcds[pcdkey]\r
                if TAB_DEFAULT not in pcd.SkuInfoList and TAB_COMMON in pcd.SkuInfoList:\r
                    pcd.SkuInfoList[TAB_DEFAULT] = pcd.SkuInfoList[TAB_COMMON]\r
                    del pcd.SkuInfoList[TAB_COMMON]\r
                elif TAB_DEFAULT in pcd.SkuInfoList and TAB_COMMON in pcd.SkuInfoList:\r
                    del pcd.SkuInfoList[TAB_COMMON]\r
\r
        map(self.FilterSkuSettings, [Pcds[pcdkey] for pcdkey in Pcds if Pcds[pcdkey].Type in DynamicPcdType])\r
        return Pcds\r
\r
    ## Retrieve non-dynamic PCD settings\r
    #\r
    #   @param  Type    PCD type\r
    #\r
    #   @retval a dict object contains settings of given PCD type\r
    #\r
    def _GetPcd(self, Type):\r
        Pcds = OrderedDict()\r
        #\r
        # tdict is a special dict kind of type, used for selecting correct\r
        # PCD settings for certain ARCH\r
        #\r
        AvailableSkuIdSet = copy.copy(self.SkuIds)\r
\r
        PcdDict = tdict(True, 3)\r
        PcdSet = set()\r
        # Find out all possible PCD candidates for self._Arch\r
        RecordList = self._RawData[Type, self._Arch]\r
        PcdValueDict = OrderedDict()\r
        for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4, Dummy5 in RecordList:\r
            SkuName = SkuName.upper()\r
            SkuName = TAB_DEFAULT if SkuName == TAB_COMMON else SkuName\r
            if SkuName not in AvailableSkuIdSet:\r
                EdkLogger.error('build ', PARAMETER_INVALID, 'Sku %s is not defined in [SkuIds] section' % SkuName,\r
                                            File=self.MetaFile, Line=Dummy5)\r
            if SkuName in (self.SkuIdMgr.SystemSkuId, TAB_DEFAULT, TAB_COMMON):\r
                if "." not in TokenSpaceGuid:\r
                    PcdSet.add((PcdCName, TokenSpaceGuid, SkuName, Dummy5))\r
                PcdDict[Arch, PcdCName, TokenSpaceGuid, SkuName] = Setting\r
\r
        for PcdCName, TokenSpaceGuid, SkuName, Dummy4 in PcdSet:\r
            Setting = PcdDict[self._Arch, PcdCName, TokenSpaceGuid, SkuName]\r
            if Setting is None:\r
                continue\r
            PcdValue, DatumType, MaxDatumSize = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)\r
            if (PcdCName, TokenSpaceGuid) in PcdValueDict:\r
                PcdValueDict[PcdCName, TokenSpaceGuid][SkuName] = (PcdValue, DatumType, MaxDatumSize)\r
            else:\r
                PcdValueDict[PcdCName, TokenSpaceGuid] = {SkuName:(PcdValue, DatumType, MaxDatumSize)}\r
\r
        for ((PcdCName, TokenSpaceGuid), PcdSetting) in PcdValueDict.iteritems():\r
            PcdValue = None\r
            DatumType = None\r
            MaxDatumSize = None\r
            if TAB_COMMON in PcdSetting:\r
                PcdValue, DatumType, MaxDatumSize = PcdSetting[TAB_COMMON]\r
            if TAB_DEFAULT in PcdSetting:\r
                PcdValue, DatumType, MaxDatumSize = PcdSetting[TAB_DEFAULT]\r
            if self.SkuIdMgr.SystemSkuId in PcdSetting:\r
                PcdValue, DatumType, MaxDatumSize = PcdSetting[self.SkuIdMgr.SystemSkuId]\r
\r
            Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(\r
                                                PcdCName,\r
                                                TokenSpaceGuid,\r
                                                self._PCD_TYPE_STRING_[Type],\r
                                                DatumType,\r
                                                PcdValue,\r
                                                '',\r
                                                MaxDatumSize,\r
                                                {},\r
                                                False,\r
                                                None,\r
                                                IsDsc=True)\r
\r
\r
        return Pcds\r
\r
    def GetStructurePcdMaxSize(self, str_pcd):\r
        pcd_default_value = str_pcd.DefaultValue\r
        sku_values = [skuobj.HiiDefaultValue if str_pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]] else skuobj.DefaultValue for skuobj in str_pcd.SkuInfoList.values()]\r
        sku_values.append(pcd_default_value)\r
\r
        def get_length(value):\r
            Value = value.strip()\r
            if len(value) > 1:\r
                if Value.startswith(TAB_GUID) and Value.endswith(')'):\r
                    return 16\r
                if Value.startswith('L"') and Value.endswith('"'):\r
                    return len(Value[2:-1])\r
                if Value[0] == '"' and Value[-1] == '"':\r
                    return len(Value) - 2\r
                if Value[0] == '{' and Value[-1] == '}':\r
                    return len(Value.split(","))\r
                if Value.startswith("L'") and Value.endswith("'") and len(list(Value[2:-1])) > 1:\r
                    return  len(list(Value[2:-1]))\r
                if Value[0] == "'" and Value[-1] == "'" and len(list(Value[1:-1])) > 1:\r
                    return len(Value) - 2\r
            return len(Value)\r
\r
        return str(max(get_length(item) for item in sku_values))\r
\r
    @staticmethod\r
    def ExecuteCommand (Command):\r
        try:\r
            Process = subprocess.Popen(Command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)\r
        except:\r
            EdkLogger.error('Build', COMMAND_FAILURE, 'Can not execute command: %s' % Command)\r
        Result = Process.communicate()\r
        return Process.returncode, Result[0], Result[1]\r
\r
    @staticmethod\r
    def IntToCString(Value, ValueSize):\r
        Result = '"'\r
        if not isinstance (Value, str):\r
            for Index in range(0, ValueSize):\r
                Result = Result + '\\x%02x' % (Value & 0xff)\r
                Value = Value >> 8\r
        Result = Result + '"'\r
        return Result\r
\r
    def GenerateSizeFunction(self, Pcd):\r
        CApp = "// Default Value in Dec \n"\r
        CApp = CApp + "void Cal_%s_%s_Size(UINT32 *Size){\n" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName)\r
        for FieldList in [Pcd.DefaultValues]:\r
            if not FieldList:\r
                continue\r
            for FieldName in FieldList:\r
                FieldName = "." + FieldName\r
                IsArray = IsFieldValueAnArray(FieldList[FieldName.strip(".")][0])\r
                if IsArray and not (FieldList[FieldName.strip(".")][0].startswith('{GUID') and FieldList[FieldName.strip(".")][0].endswith('}')):\r
                    try:\r
                        Value = ValueExpressionEx(FieldList[FieldName.strip(".")][0], TAB_VOID, self._GuidDict)(True)\r
                    except BadExpression:\r
                        EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " %\r
                                        (".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldName.strip('.'))), FieldList[FieldName.strip(".")][1], FieldList[FieldName.strip(".")][2]))\r
                    Value, ValueSize = ParseFieldValue(Value)\r
                    CApp = CApp + '  __FLEXIBLE_SIZE(*Size, %s, %s, %d / __ARRAY_ELEMENT_SIZE(%s, %s) + ((%d %% __ARRAY_ELEMENT_SIZE(%s, %s)) ? 1 : 0));  // From %s Line %d Value %s \n' % (Pcd.DatumType, FieldName.strip("."), ValueSize, Pcd.DatumType, FieldName.strip("."), ValueSize, Pcd.DatumType, FieldName.strip("."), FieldList[FieldName.strip(".")][1], FieldList[FieldName.strip(".")][2], FieldList[FieldName.strip(".")][0]);\r
                else:\r
                    NewFieldName = ''\r
                    FieldName_ori = FieldName.strip('.')\r
                    while '[' in  FieldName:\r
                        NewFieldName = NewFieldName + FieldName.split('[', 1)[0] + '[0]'\r
                        ArrayIndex = int(FieldName.split('[', 1)[1].split(']', 1)[0])\r
                        FieldName = FieldName.split(']', 1)[1]\r
                    FieldName = NewFieldName + FieldName\r
                    while '[' in FieldName:\r
                        FieldName = FieldName.rsplit('[', 1)[0]\r
                        CApp = CApp + '  __FLEXIBLE_SIZE(*Size, %s, %s, %d); // From %s Line %d Value %s\n' % (Pcd.DatumType, FieldName.strip("."), ArrayIndex + 1, FieldList[FieldName_ori][1], FieldList[FieldName_ori][2], FieldList[FieldName_ori][0])\r
        for skuname in Pcd.SkuOverrideValues:\r
            if skuname == TAB_COMMON:\r
                continue\r
            for defaultstorenameitem in Pcd.SkuOverrideValues[skuname]:\r
                CApp = CApp + "// SkuName: %s,  DefaultStoreName: %s \n" % (skuname, defaultstorenameitem)\r
                for FieldList in [Pcd.SkuOverrideValues[skuname].get(defaultstorenameitem)]:\r
                    if not FieldList:\r
                        continue\r
                    for FieldName in FieldList:\r
                        FieldName = "." + FieldName\r
                        IsArray = IsFieldValueAnArray(FieldList[FieldName.strip(".")][0])\r
                        if IsArray and not (FieldList[FieldName.strip(".")][0].startswith('{GUID') and FieldList[FieldName.strip(".")][0].endswith('}')):\r
                            try:\r
                                Value = ValueExpressionEx(FieldList[FieldName.strip(".")][0], TAB_VOID, self._GuidDict)(True)\r
                            except BadExpression:\r
                                EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " %\r
                                                (".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldName.strip('.'))), FieldList[FieldName.strip(".")][1], FieldList[FieldName.strip(".")][2]))\r
                            Value, ValueSize = ParseFieldValue(Value)\r
                            CApp = CApp + '  __FLEXIBLE_SIZE(*Size, %s, %s, %d / __ARRAY_ELEMENT_SIZE(%s, %s) + ((%d %% __ARRAY_ELEMENT_SIZE(%s, %s)) ? 1 : 0)); // From %s Line %d Value %s\n' % (Pcd.DatumType, FieldName.strip("."), ValueSize, Pcd.DatumType, FieldName.strip("."), ValueSize, Pcd.DatumType, FieldName.strip("."), FieldList[FieldName.strip(".")][1], FieldList[FieldName.strip(".")][2], FieldList[FieldName.strip(".")][0]);\r
                        else:\r
                            NewFieldName = ''\r
                            FieldName_ori = FieldName.strip('.')\r
                            while '[' in  FieldName:\r
                                NewFieldName = NewFieldName + FieldName.split('[', 1)[0] + '[0]'\r
                                ArrayIndex = int(FieldName.split('[', 1)[1].split(']', 1)[0])\r
                                FieldName = FieldName.split(']', 1)[1]\r
                            FieldName = NewFieldName + FieldName\r
                            while '[' in FieldName:\r
                                FieldName = FieldName.rsplit('[', 1)[0]\r
                                CApp = CApp + '  __FLEXIBLE_SIZE(*Size, %s, %s, %d); // From %s Line %d Value %s \n' % (Pcd.DatumType, FieldName.strip("."), ArrayIndex + 1, FieldList[FieldName_ori][1], FieldList[FieldName_ori][2], FieldList[FieldName_ori][0])\r
        if Pcd.PcdFieldValueFromComm:\r
            CApp = CApp + "// From Command Line \n"\r
        for FieldName in Pcd.PcdFieldValueFromComm:\r
            FieldName = "." + FieldName\r
            IsArray = IsFieldValueAnArray(Pcd.PcdFieldValueFromComm[FieldName.strip(".")][0])\r
            if IsArray and not (Pcd.PcdFieldValueFromComm[FieldName.strip(".")][0].startswith('{GUID') and Pcd.PcdFieldValueFromComm[FieldName.strip(".")][0].endswith('}')):\r
                try:\r
                    Value = ValueExpressionEx(Pcd.PcdFieldValueFromComm[FieldName.strip(".")][0], TAB_VOID, self._GuidDict)(True)\r
                except BadExpression:\r
                    EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " %\r
                                    (".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldName.strip('.'))), Pcd.PcdFieldValueFromComm[FieldName.strip(".")][1], Pcd.PcdFieldValueFromComm[FieldName.strip(".")][2]))\r
                Value, ValueSize = ParseFieldValue(Value)\r
                CApp = CApp + '  __FLEXIBLE_SIZE(*Size, %s, %s, %d / __ARRAY_ELEMENT_SIZE(%s, %s) + ((%d %% __ARRAY_ELEMENT_SIZE(%s, %s)) ? 1 : 0)); // From %s Line %d Value %s\n' % (Pcd.DatumType, FieldName.strip("."), ValueSize, Pcd.DatumType, FieldName.strip("."), ValueSize, Pcd.DatumType, FieldName.strip("."), Pcd.PcdFieldValueFromComm[FieldName.strip(".")][1], Pcd.PcdFieldValueFromComm[FieldName.strip(".")][2], Pcd.PcdFieldValueFromComm[FieldName.strip(".")][0]);\r
            else:\r
                NewFieldName = ''\r
                FieldName_ori = FieldName.strip('.')\r
                while '[' in  FieldName:\r
                    NewFieldName = NewFieldName + FieldName.split('[', 1)[0] + '[0]'\r
                    ArrayIndex = int(FieldName.split('[', 1)[1].split(']', 1)[0])\r
                    FieldName = FieldName.split(']', 1)[1]\r
                FieldName = NewFieldName + FieldName\r
                while '[' in FieldName:\r
                    FieldName = FieldName.rsplit('[', 1)[0]\r
                    CApp = CApp + '  __FLEXIBLE_SIZE(*Size, %s, %s, %d); // From %s Line %d Value %s \n' % (Pcd.DatumType, FieldName.strip("."), ArrayIndex + 1, Pcd.PcdFieldValueFromComm[FieldName_ori][1], Pcd.PcdFieldValueFromComm[FieldName_ori][2], Pcd.PcdFieldValueFromComm[FieldName_ori][0])\r
        CApp = CApp + "  *Size = (%d > *Size ? %d : *Size); // The Pcd maxsize is %d \n" % (Pcd.GetPcdMaxSize(), Pcd.GetPcdMaxSize(), Pcd.GetPcdMaxSize())\r
        CApp = CApp + "}\n"\r
        return CApp\r
\r
    @staticmethod\r
    def GenerateSizeStatments(Pcd):\r
        CApp = '  Size = sizeof(%s);\n' % (Pcd.DatumType)\r
        CApp = CApp + '  Cal_%s_%s_Size(&Size);\n' % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName)\r
        return CApp\r
\r
    def GenerateDefaultValueAssignFunction(self, Pcd):\r
        CApp = "// Default value in Dec \n"\r
        CApp = CApp + "void Assign_%s_%s_Default_Value(%s *Pcd){\n" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, Pcd.DatumType)\r
        CApp = CApp + '  UINT32  FieldSize;\n'\r
        CApp = CApp + '  CHAR8   *Value;\n'\r
        DefaultValueFromDec = Pcd.DefaultValueFromDec\r
        IsArray = IsFieldValueAnArray(Pcd.DefaultValueFromDec)\r
        if IsArray:\r
            try:\r
                DefaultValueFromDec = ValueExpressionEx(Pcd.DefaultValueFromDec, TAB_VOID)(True)\r
            except BadExpression:\r
                EdkLogger.error("Build", FORMAT_INVALID, "Invalid value format for %s.%s, from DEC: %s" %\r
                                (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, DefaultValueFromDec))\r
        DefaultValueFromDec = StringToArray(DefaultValueFromDec)\r
        Value, ValueSize = ParseFieldValue (DefaultValueFromDec)\r
        if isinstance(Value, str):\r
            CApp = CApp + '  Pcd = %s; // From DEC Default Value %s\n' % (Value, Pcd.DefaultValueFromDec)\r
        elif IsArray:\r
        #\r
        # Use memcpy() to copy value into field\r
        #\r
            CApp = CApp + '  Value     = %s; // From DEC Default Value %s\n' % (DscBuildData.IntToCString(Value, ValueSize), Pcd.DefaultValueFromDec)\r
            CApp = CApp + '  memcpy (Pcd, Value, %d);\n' % (ValueSize)\r
        for FieldList in [Pcd.DefaultValues]:\r
            if not FieldList:\r
                continue\r
            for FieldName in FieldList:\r
                IsArray = IsFieldValueAnArray(FieldList[FieldName][0])\r
                if IsArray:\r
                    try:\r
                        FieldList[FieldName][0] = ValueExpressionEx(FieldList[FieldName][0], TAB_VOID, self._GuidDict)(True)\r
                    except BadExpression:\r
                        EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " %\r
                                        (".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldName)), FieldList[FieldName][1], FieldList[FieldName][2]))\r
\r
                try:\r
                    Value, ValueSize = ParseFieldValue (FieldList[FieldName][0])\r
                except Exception:\r
                    EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " % (".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldName)), FieldList[FieldName][1], FieldList[FieldName][2]))\r
                if isinstance(Value, str):\r
                    CApp = CApp + '  Pcd->%s = %s; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])\r
                elif IsArray:\r
                    #\r
                    # Use memcpy() to copy value into field\r
                    #\r
                    CApp = CApp + '  FieldSize = __FIELD_SIZE(%s, %s);\n' % (Pcd.DatumType, FieldName)\r
                    CApp = CApp + '  Value     = %s; // From %s Line %d Value %s\n' % (DscBuildData.IntToCString(Value, ValueSize), FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])\r
                    CApp = CApp + '  memcpy (&Pcd->%s, Value, (FieldSize > 0 && FieldSize < %d) ? FieldSize : %d);\n' % (FieldName, ValueSize, ValueSize)\r
                else:\r
                    if ValueSize > 4:\r
                        CApp = CApp + '  Pcd->%s = %dULL; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])\r
                    else:\r
                        CApp = CApp + '  Pcd->%s = %d; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])\r
        CApp = CApp + "}\n"\r
        return CApp\r
\r
    @staticmethod\r
    def GenerateDefaultValueAssignStatement(Pcd):\r
        CApp = '  Assign_%s_%s_Default_Value(Pcd);\n' % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName)\r
        return CApp\r
\r
    def GenerateInitValueFunction(self, Pcd, SkuName, DefaultStoreName):\r
        CApp = "// Value in Dsc for Sku: %s, DefaultStore %s\n" % (SkuName, DefaultStoreName)\r
        CApp = CApp + "void Assign_%s_%s_%s_%s_Value(%s *Pcd){\n" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, SkuName, DefaultStoreName, Pcd.DatumType)\r
        CApp = CApp + '  UINT32  FieldSize;\n'\r
        CApp = CApp + '  CHAR8   *Value;\n'\r
\r
        CApp = CApp + "// SkuName: %s,  DefaultStoreName: %s \n" % (TAB_DEFAULT, TAB_DEFAULT_STORES_DEFAULT)\r
        inherit_OverrideValues = Pcd.SkuOverrideValues[SkuName]\r
        if (SkuName, DefaultStoreName) == (TAB_DEFAULT, TAB_DEFAULT_STORES_DEFAULT):\r
            pcddefaultvalue = Pcd.DefaultFromDSC.get(TAB_DEFAULT, {}).get(TAB_DEFAULT_STORES_DEFAULT, Pcd.DefaultValue) if Pcd.DefaultFromDSC else Pcd.DefaultValue\r
        else:\r
            if not Pcd.DscRawValue:\r
                # handle the case that structure pcd is not appear in DSC\r
                self.CopyDscRawValue(Pcd)\r
            pcddefaultvalue = Pcd.DscRawValue.get(SkuName, {}).get(DefaultStoreName)\r
        for FieldList in [pcddefaultvalue, inherit_OverrideValues.get(DefaultStoreName)]:\r
            if not FieldList:\r
                continue\r
            if pcddefaultvalue and FieldList == pcddefaultvalue:\r
                IsArray = IsFieldValueAnArray(FieldList)\r
                if IsArray:\r
                    try:\r
                        FieldList = ValueExpressionEx(FieldList, TAB_VOID)(True)\r
                    except BadExpression:\r
                        EdkLogger.error("Build", FORMAT_INVALID, "Invalid value format for %s.%s, from DSC: %s" %\r
                                        (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldList))\r
                Value, ValueSize = ParseFieldValue (FieldList)\r
\r
                if (SkuName, DefaultStoreName) == (TAB_DEFAULT, TAB_DEFAULT_STORES_DEFAULT):\r
                    if isinstance(Value, str):\r
                        CApp = CApp + '  Pcd = %s; // From DSC Default Value %s\n' % (Value, Pcd.DefaultFromDSC.get(TAB_DEFAULT, {}).get(TAB_DEFAULT_STORES_DEFAULT, Pcd.DefaultValue) if Pcd.DefaultFromDSC else Pcd.DefaultValue)\r
                    elif IsArray:\r
                    #\r
                    # Use memcpy() to copy value into field\r
                    #\r
                        CApp = CApp + '  Value     = %s; // From DSC Default Value %s\n' % (DscBuildData.IntToCString(Value, ValueSize), Pcd.DefaultFromDSC.get(TAB_DEFAULT, {}).get(TAB_DEFAULT_STORES_DEFAULT, Pcd.DefaultValue) if Pcd.DefaultFromDSC else Pcd.DefaultValue)\r
                        CApp = CApp + '  memcpy (Pcd, Value, %d);\n' % (ValueSize)\r
                else:\r
                    if isinstance(Value, str):\r
                        CApp = CApp + '  Pcd = %s; // From DSC Default Value %s\n' % (Value, Pcd.DscRawValue.get(SkuName, {}).get(DefaultStoreName))\r
                    elif IsArray:\r
                    #\r
                    # Use memcpy() to copy value into field\r
                    #\r
                        CApp = CApp + '  Value     = %s; // From DSC Default Value %s\n' % (DscBuildData.IntToCString(Value, ValueSize), Pcd.DscRawValue.get(SkuName, {}).get(DefaultStoreName))\r
                        CApp = CApp + '  memcpy (Pcd, Value, %d);\n' % (ValueSize)\r
                continue\r
            if (SkuName, DefaultStoreName) == (TAB_DEFAULT, TAB_DEFAULT_STORES_DEFAULT) or (( (SkuName, '') not in Pcd.ValueChain) and ( (SkuName, DefaultStoreName) not in Pcd.ValueChain )):\r
                for FieldName in FieldList:\r
                    IsArray = IsFieldValueAnArray(FieldList[FieldName][0])\r
                    if IsArray:\r
                        try:\r
                            FieldList[FieldName][0] = ValueExpressionEx(FieldList[FieldName][0], TAB_VOID, self._GuidDict)(True)\r
                        except BadExpression:\r
                            EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " %\r
                                            (".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldName)), FieldList[FieldName][1], FieldList[FieldName][2]))\r
                    try:\r
                        Value, ValueSize = ParseFieldValue (FieldList[FieldName][0])\r
                    except Exception:\r
                        EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " % (".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldName)), FieldList[FieldName][1], FieldList[FieldName][2]))\r
                    if isinstance(Value, str):\r
                        CApp = CApp + '  Pcd->%s = %s; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])\r
                    elif IsArray:\r
                    #\r
                    # Use memcpy() to copy value into field\r
                    #\r
                        CApp = CApp + '  FieldSize = __FIELD_SIZE(%s, %s);\n' % (Pcd.DatumType, FieldName)\r
                        CApp = CApp + '  Value     = %s; // From %s Line %d Value %s\n' % (DscBuildData.IntToCString(Value, ValueSize), FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])\r
                        CApp = CApp + '  memcpy (&Pcd->%s, Value, (FieldSize > 0 && FieldSize < %d) ? FieldSize : %d);\n' % (FieldName, ValueSize, ValueSize)\r
                    else:\r
                        if ValueSize > 4:\r
                            CApp = CApp + '  Pcd->%s = %dULL; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])\r
                        else:\r
                            CApp = CApp + '  Pcd->%s = %d; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])\r
        CApp = CApp + "}\n"\r
        return CApp\r
\r
    @staticmethod\r
    def GenerateInitValueStatement(Pcd, SkuName, DefaultStoreName):\r
        CApp = '  Assign_%s_%s_%s_%s_Value(Pcd);\n' % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, SkuName, DefaultStoreName)\r
        return CApp\r
\r
    def GenerateCommandLineValue(self, Pcd):\r
        CApp = "// Value in CommandLine\n"\r
        CApp = CApp + "void Assign_%s_%s_CommandLine_Value(%s *Pcd){\n" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, Pcd.DatumType)\r
        CApp = CApp + '  UINT32  FieldSize;\n'\r
        CApp = CApp + '  CHAR8   *Value;\n'\r
\r
        pcddefaultvalue = Pcd.PcdValueFromComm\r
        for FieldList in [pcddefaultvalue, Pcd.PcdFieldValueFromComm]:\r
            if not FieldList:\r
                continue\r
            if pcddefaultvalue and FieldList == pcddefaultvalue:\r
                IsArray = IsFieldValueAnArray(FieldList)\r
                if IsArray:\r
                    try:\r
                        FieldList = ValueExpressionEx(FieldList, TAB_VOID)(True)\r
                    except BadExpression:\r
                        EdkLogger.error("Build", FORMAT_INVALID, "Invalid value format for %s.%s, from Command: %s" %\r
                                        (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldList))\r
                Value, ValueSize = ParseFieldValue (FieldList)\r
\r
                if isinstance(Value, str):\r
                    CApp = CApp + '  Pcd = %s; // From Command Line \n' % (Value)\r
                elif IsArray:\r
                #\r
                # Use memcpy() to copy value into field\r
                #\r
                    CApp = CApp + '  Value     = %s; // From Command Line.\n' % (DscBuildData.IntToCString(Value, ValueSize))\r
                    CApp = CApp + '  memcpy (Pcd, Value, %d);\n' % (ValueSize)\r
                continue\r
            for FieldName in FieldList:\r
                IsArray = IsFieldValueAnArray(FieldList[FieldName][0])\r
                if IsArray:\r
                    try:\r
                        FieldList[FieldName][0] = ValueExpressionEx(FieldList[FieldName][0], TAB_VOID, self._GuidDict)(True)\r
                    except BadExpression:\r
                        EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " %\r
                                        (".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldName)), FieldList[FieldName][1], FieldList[FieldName][2]))\r
                    except:\r
                        print("error")\r
                try:\r
                    Value, ValueSize = ParseFieldValue (FieldList[FieldName][0])\r
                except Exception:\r
                    EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " % (".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldName)), FieldList[FieldName][1], FieldList[FieldName][2]))\r
                if isinstance(Value, str):\r
                    CApp = CApp + '  Pcd->%s = %s; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])\r
                elif IsArray:\r
                #\r
                # Use memcpy() to copy value into field\r
                #\r
                    CApp = CApp + '  FieldSize = __FIELD_SIZE(%s, %s);\n' % (Pcd.DatumType, FieldName)\r
                    CApp = CApp + '  Value     = %s; // From %s Line %d Value %s\n' % (DscBuildData.IntToCString(Value, ValueSize), FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])\r
                    CApp = CApp + '  memcpy (&Pcd->%s, Value, (FieldSize > 0 && FieldSize < %d) ? FieldSize : %d);\n' % (FieldName, ValueSize, ValueSize)\r
                else:\r
                    if ValueSize > 4:\r
                        CApp = CApp + '  Pcd->%s = %dULL; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])\r
                    else:\r
                        CApp = CApp + '  Pcd->%s = %d; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])\r
        CApp = CApp + "}\n"\r
        return CApp\r
\r
    @staticmethod\r
    def GenerateCommandLineValueStatement(Pcd):\r
        CApp = '  Assign_%s_%s_CommandLine_Value(Pcd);\n' % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName)\r
        return CApp\r
\r
    def GenerateInitializeFunc(self, SkuName, DefaultStore, Pcd, InitByteValue, CApp):\r
        OverrideValues = {DefaultStore:""}\r
        if Pcd.SkuOverrideValues:\r
            OverrideValues = Pcd.SkuOverrideValues[SkuName]\r
        for DefaultStoreName in OverrideValues:\r
            CApp = CApp + 'void\n'\r
            CApp = CApp + 'Initialize_%s_%s_%s_%s(\n' % (SkuName, DefaultStoreName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName)\r
            CApp = CApp + '  void\n'\r
            CApp = CApp + '  )\n'\r
            CApp = CApp + '{\n'\r
            CApp = CApp + '  UINT32  Size;\n'\r
            CApp = CApp + '  UINT32  FieldSize;\n'\r
            CApp = CApp + '  CHAR8   *Value;\n'\r
            CApp = CApp + '  UINT32  OriginalSize;\n'\r
            CApp = CApp + '  VOID    *OriginalPcd;\n'\r
            CApp = CApp + '  %s      *Pcd;  // From %s Line %d \n' % (Pcd.DatumType, Pcd.PkgPath, Pcd.PcdDefineLineNo)\r
            CApp = CApp + '\n'\r
\r
            if SkuName in Pcd.SkuInfoList:\r
                DefaultValue = Pcd.SkuInfoList[SkuName].DefaultStoreDict.get(DefaultStoreName, Pcd.SkuInfoList[SkuName].HiiDefaultValue if Pcd.SkuInfoList[SkuName].HiiDefaultValue  else Pcd.SkuInfoList[SkuName].DefaultValue)\r
            else:\r
                DefaultValue = Pcd.DefaultValue\r
            PcdDefaultValue = StringToArray(DefaultValue.strip())\r
\r
            InitByteValue += '%s.%s.%s.%s|%s|%s\n' % (SkuName, DefaultStoreName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName, Pcd.DatumType, PcdDefaultValue)\r
\r
            #\r
            # Get current PCD value and size\r
            #\r
            CApp = CApp + '  OriginalPcd = PcdGetPtr (%s, %s, %s, %s, &OriginalSize);\n' % (SkuName, DefaultStoreName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName)\r
\r
            #\r
            # Determine the size of the PCD.  For simple structures, sizeof(TYPE) provides\r
            # the correct value.  For structures with a flexible array member, the flexible\r
            # array member is detected, and the size is based on the highest index used with\r
            # the flexible array member.  The flexible array member must be the last field\r
            # in a structure.  The size formula for this case is:\r
            # OFFSET_OF(FlexbleArrayField) + sizeof(FlexibleArray[0]) * (HighestIndex + 1)\r
            #\r
            CApp = CApp + DscBuildData.GenerateSizeStatments(Pcd)\r
\r
            #\r
            # Allocate and zero buffer for the PCD\r
            # Must handle cases where current value is smaller, larger, or same size\r
            # Always keep that larger one as the current size\r
            #\r
            CApp = CApp + '  Size = (OriginalSize > Size ? OriginalSize : Size);\n'\r
            CApp = CApp + '  Pcd     = (%s *)malloc (Size);\n' % (Pcd.DatumType)\r
            CApp = CApp + '  memset (Pcd, 0, Size);\n'\r
\r
            #\r
            # Copy current PCD value into allocated buffer.\r
            #\r
            CApp = CApp + '  memcpy (Pcd, OriginalPcd, OriginalSize);\n'\r
\r
            #\r
            # Assign field values in PCD\r
            #\r
            CApp = CApp + DscBuildData.GenerateDefaultValueAssignStatement(Pcd)\r
            if Pcd.Type not in [self._PCD_TYPE_STRING_[MODEL_PCD_FIXED_AT_BUILD],\r
                        self._PCD_TYPE_STRING_[MODEL_PCD_PATCHABLE_IN_MODULE]]:\r
                for skuname in self.SkuIdMgr.GetSkuChain(SkuName):\r
                    storeset = [DefaultStoreName] if DefaultStoreName == TAB_DEFAULT_STORES_DEFAULT else [TAB_DEFAULT_STORES_DEFAULT, DefaultStoreName]\r
                    for defaultstorenameitem in storeset:\r
                        CApp = CApp + "// SkuName: %s,  DefaultStoreName: %s \n" % (skuname, defaultstorenameitem)\r
                        CApp = CApp + DscBuildData.GenerateInitValueStatement(Pcd, skuname, defaultstorenameitem)\r
                    if skuname == SkuName:\r
                        break\r
            else:\r
                CApp = CApp + "// SkuName: %s,  DefaultStoreName: STANDARD \n" % self.SkuIdMgr.SystemSkuId\r
                CApp = CApp + DscBuildData.GenerateInitValueStatement(Pcd, self.SkuIdMgr.SystemSkuId, TAB_DEFAULT_STORES_DEFAULT)\r
            CApp = CApp + DscBuildData.GenerateCommandLineValueStatement(Pcd)\r
            #\r
            # Set new PCD value and size\r
            #\r
            CApp = CApp + '  PcdSetPtr (%s, %s, %s, %s, Size, (UINT8 *)Pcd);\n' % (SkuName, DefaultStoreName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName)\r
\r
            #\r
            # Free PCD\r
            #\r
            CApp = CApp + '  free (Pcd);\n'\r
            CApp = CApp + '}\n'\r
            CApp = CApp + '\n'\r
        return InitByteValue, CApp\r
\r
    def GenerateByteArrayValue (self, StructuredPcds):\r
        #\r
        # Generate/Compile/Run C application to determine if there are any flexible array members\r
        #\r
        if not StructuredPcds:\r
            return\r
\r
        InitByteValue = ""\r
        CApp = PcdMainCHeader\r
\r
        IncludeFiles = set()\r
        for PcdName in StructuredPcds:\r
            Pcd = StructuredPcds[PcdName]\r
            for IncludeFile in Pcd.StructuredPcdIncludeFile:\r
                if IncludeFile not in IncludeFiles:\r
                    IncludeFiles.add(IncludeFile)\r
                    CApp = CApp + '#include <%s>\n' % (IncludeFile)\r
        CApp = CApp + '\n'\r
        for PcdName in StructuredPcds:\r
            Pcd = StructuredPcds[PcdName]\r
            CApp = CApp + self.GenerateSizeFunction(Pcd)\r
            CApp = CApp + self.GenerateDefaultValueAssignFunction(Pcd)\r
            CApp = CApp + self.GenerateCommandLineValue(Pcd)\r
            if not Pcd.SkuOverrideValues or Pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_FIXED_AT_BUILD],\r
                        self._PCD_TYPE_STRING_[MODEL_PCD_PATCHABLE_IN_MODULE]]:\r
                CApp = CApp + self.GenerateInitValueFunction(Pcd, self.SkuIdMgr.SystemSkuId, TAB_DEFAULT_STORES_DEFAULT)\r
            else:\r
                for SkuName in self.SkuIdMgr.SkuOverrideOrder():\r
                    if SkuName not in Pcd.SkuOverrideValues:\r
                        continue\r
                    for DefaultStoreName in Pcd.SkuOverrideValues[SkuName]:\r
                        CApp = CApp + self.GenerateInitValueFunction(Pcd, SkuName, DefaultStoreName)\r
            if not Pcd.SkuOverrideValues or Pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_FIXED_AT_BUILD],\r
                        self._PCD_TYPE_STRING_[MODEL_PCD_PATCHABLE_IN_MODULE]]:\r
                InitByteValue, CApp = self.GenerateInitializeFunc(self.SkuIdMgr.SystemSkuId, TAB_DEFAULT_STORES_DEFAULT, Pcd, InitByteValue, CApp)\r
            else:\r
                for SkuName in self.SkuIdMgr.SkuOverrideOrder():\r
                    if SkuName not in Pcd.SkuOverrideValues:\r
                        continue\r
                    for DefaultStoreName in Pcd.DefaultStoreName:\r
                        Pcd = StructuredPcds[PcdName]\r
                        InitByteValue, CApp = self.GenerateInitializeFunc(SkuName, DefaultStoreName, Pcd, InitByteValue, CApp)\r
\r
        CApp = CApp + 'VOID\n'\r
        CApp = CApp + 'PcdEntryPoint(\n'\r
        CApp = CApp + '  VOID\n'\r
        CApp = CApp + '  )\n'\r
        CApp = CApp + '{\n'\r
        for Pcd in StructuredPcds.values():\r
            if not Pcd.SkuOverrideValues or Pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_FIXED_AT_BUILD], self._PCD_TYPE_STRING_[MODEL_PCD_PATCHABLE_IN_MODULE]]:\r
                CApp = CApp + '  Initialize_%s_%s_%s_%s();\n' % (self.SkuIdMgr.SystemSkuId, TAB_DEFAULT_STORES_DEFAULT, Pcd.TokenSpaceGuidCName, Pcd.TokenCName)\r
            else:\r
                for SkuName in self.SkuIdMgr.SkuOverrideOrder():\r
                    if SkuName not in Pcd.SkuOverrideValues:\r
                        continue\r
                    for DefaultStoreName in Pcd.SkuOverrideValues[SkuName]:\r
                        CApp = CApp + '  Initialize_%s_%s_%s_%s();\n' % (SkuName, DefaultStoreName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName)\r
        CApp = CApp + '}\n'\r
\r
        CApp = CApp + PcdMainCEntry + '\n'\r
\r
        if not os.path.exists(self.OutputPath):\r
            os.makedirs(self.OutputPath)\r
        CAppBaseFileName = os.path.join(self.OutputPath, PcdValueInitName)\r
        SaveFileOnChange(CAppBaseFileName + '.c', CApp, False)\r
\r
        MakeApp = PcdMakefileHeader\r
        if sys.platform == "win32":\r
            MakeApp = MakeApp + 'APPNAME = %s\n' % (PcdValueInitName) + 'OBJECTS = %s\%s.obj\n' % (self.OutputPath, PcdValueInitName) + 'INC = '\r
        else:\r
            MakeApp = MakeApp + PcdGccMakefile\r
            MakeApp = MakeApp + 'APPNAME = %s\n' % (PcdValueInitName) + 'OBJECTS = %s/%s.o\n' % (self.OutputPath, PcdValueInitName) + \\r
                      'include $(MAKEROOT)/Makefiles/app.makefile\n' + 'INCLUDE +='\r
\r
        IncSearchList = []\r
        PlatformInc = {}\r
        for Cache in self._Bdb._CACHE_.values():\r
            if Cache.MetaFile.Ext.lower() != '.dec':\r
                continue\r
            if Cache.Includes:\r
                if str(Cache.MetaFile.Path) not in PlatformInc:\r
                    PlatformInc[str(Cache.MetaFile.Path)] = []\r
                    PlatformInc[str(Cache.MetaFile.Path)].append (os.path.dirname(Cache.MetaFile.Path))\r
                    PlatformInc[str(Cache.MetaFile.Path)].extend (Cache.CommonIncludes)\r
\r
        PcdDependDEC = []\r
        for Pcd in StructuredPcds.values():\r
            for PackageDec in Pcd.PackageDecs:\r
                Package = os.path.normpath(mws.join(GlobalData.gWorkspace, PackageDec))\r
                if not os.path.exists(Package):\r
                    EdkLogger.error('Build', RESOURCE_NOT_AVAILABLE, "The dependent Package %s of PCD %s.%s is not exist." % (PackageDec, Pcd.TokenSpaceGuidCName, Pcd.TokenCName))\r
                if Package not in PcdDependDEC:\r
                    PcdDependDEC.append(Package)\r
\r
        if PlatformInc and PcdDependDEC:\r
            for pkg in PcdDependDEC:\r
                if pkg in PlatformInc:\r
                    for inc in PlatformInc[pkg]:\r
                        MakeApp += '-I'  + str(inc) + ' '\r
                        IncSearchList.append(inc)\r
        MakeApp = MakeApp + '\n'\r
\r
        CC_FLAGS = LinuxCFLAGS\r
        if sys.platform == "win32":\r
            CC_FLAGS = WindowsCFLAGS\r
        BuildOptions = {}\r
        for Options in self.BuildOptions:\r
            if Options[2] != EDKII_NAME:\r
                continue\r
            Family = Options[0]\r
            if Family and Family != self.ToolChainFamily:\r
                continue\r
            Target, Tag, Arch, Tool, Attr = Options[1].split("_")\r
            if Tool != 'CC':\r
                continue\r
\r
            if Target == "*" or Target == self._Target:\r
                if Tag == "*" or Tag == self._Toolchain:\r
                    if Arch == "*" or Arch == self.Arch:\r
                        if Tool not in BuildOptions:\r
                            BuildOptions[Tool] = {}\r
                        if Attr != "FLAGS" or Attr not in BuildOptions[Tool] or self.BuildOptions[Options].startswith('='):\r
                            BuildOptions[Tool][Attr] = self.BuildOptions[Options]\r
                        else:\r
                            # append options for the same tool except PATH\r
                            if Attr != 'PATH':\r
                                BuildOptions[Tool][Attr] += " " + self.BuildOptions[Options]\r
                            else:\r
                                BuildOptions[Tool][Attr] = self.BuildOptions[Options]\r
        if BuildOptions:\r
            for Tool in BuildOptions:\r
                for Attr in BuildOptions[Tool]:\r
                    if Attr == "FLAGS":\r
                        Value = BuildOptions[Tool][Attr]\r
                        ValueList = Value.split()\r
                        if ValueList:\r
                            for Id, Item in enumerate(ValueList):\r
                                if Item in ['-D', '/D', '-U', '/U']:\r
                                    CC_FLAGS += ' ' + Item\r
                                    if Id + 1 < len(ValueList):\r
                                        CC_FLAGS += ' ' + ValueList[Id + 1]\r
                                elif Item.startswith(('-D', '/D', '-U', '/U')):\r
                                    CC_FLAGS += ' ' + Item\r
        MakeApp += CC_FLAGS\r
\r
        if sys.platform == "win32":\r
            MakeApp = MakeApp + PcdMakefileEnd\r
        MakeApp = MakeApp + '\n'\r
        IncludeFileFullPaths = []\r
        for includefile in IncludeFiles:\r
            for includepath in IncSearchList:\r
                includefullpath = os.path.join(str(includepath), includefile)\r
                if os.path.exists(includefullpath):\r
                    IncludeFileFullPaths.append(os.path.normpath(includefullpath))\r
                    break\r
        SearchPathList = []\r
        SearchPathList.append(os.path.normpath(mws.join(GlobalData.gWorkspace, "BaseTools/Source/C/Include")))\r
        SearchPathList.append(os.path.normpath(mws.join(GlobalData.gWorkspace, "BaseTools/Source/C/Common")))\r
        SearchPathList.extend(str(item) for item in IncSearchList)\r
        IncFileList = GetDependencyList(IncludeFileFullPaths, SearchPathList)\r
        for include_file in IncFileList:\r
            MakeApp += "$(OBJECTS) : %s\n" % include_file\r
        MakeFileName = os.path.join(self.OutputPath, 'Makefile')\r
        MakeApp += "$(OBJECTS) : %s\n" % MakeFileName\r
        SaveFileOnChange(MakeFileName, MakeApp, False)\r
\r
        InputValueFile = os.path.join(self.OutputPath, 'Input.txt')\r
        OutputValueFile = os.path.join(self.OutputPath, 'Output.txt')\r
        SaveFileOnChange(InputValueFile, InitByteValue, False)\r
\r
        PcdValueInitExe = PcdValueInitName\r
        if not sys.platform == "win32":\r
            PcdValueInitExe = os.path.join(os.getenv("EDK_TOOLS_PATH"), 'Source', 'C', 'bin', PcdValueInitName)\r
        else:\r
            PcdValueInitExe = os.path.join(os.getenv("EDK_TOOLS_PATH"), 'Bin', 'Win32', PcdValueInitName) +".exe"\r
\r
        Messages = ''\r
        if sys.platform == "win32":\r
            MakeCommand = 'nmake -f %s' % (MakeFileName)\r
            returncode, StdOut, StdErr = DscBuildData.ExecuteCommand (MakeCommand)\r
            Messages = StdOut\r
        else:\r
            MakeCommand = 'make -f %s' % (MakeFileName)\r
            returncode, StdOut, StdErr = DscBuildData.ExecuteCommand (MakeCommand)\r
            Messages = StdErr\r
        Messages = Messages.split('\n')\r
        MessageGroup = []\r
        if returncode <>0:\r
            CAppBaseFileName = os.path.join(self.OutputPath, PcdValueInitName)\r
            File = open (CAppBaseFileName + '.c', 'r')\r
            FileData = File.readlines()\r
            File.close()\r
            for Message in Messages:\r
                if " error" in Message or "warning" in Message:\r
                    FileInfo = Message.strip().split('(')\r
                    if len (FileInfo) > 1:\r
                        FileName = FileInfo [0]\r
                        FileLine = FileInfo [1].split (')')[0]\r
                    else:\r
                        FileInfo = Message.strip().split(':')\r
                        FileName = FileInfo [0]\r
                        FileLine = FileInfo [1]\r
                    if FileLine.isdigit():\r
                        error_line = FileData[int (FileLine) - 1]\r
                        if r"//" in error_line:\r
                            c_line, dsc_line = error_line.split(r"//")\r
                        else:\r
                            dsc_line = error_line\r
                        message_itmes = Message.split(":")\r
                        Index = 0\r
                        if "PcdValueInit.c" not in Message:\r
                            if not MessageGroup:\r
                                MessageGroup.append(Message)\r
                            break\r
                        else:\r
                            for item in message_itmes:\r
                                if "PcdValueInit.c" in item:\r
                                    Index = message_itmes.index(item)\r
                                    message_itmes[Index] = dsc_line.strip()\r
                                    break\r
                            MessageGroup.append(":".join(message_itmes[Index:]).strip())\r
                            continue\r
                    else:\r
                        MessageGroup.append(Message)\r
            if MessageGroup:\r
                EdkLogger.error("build", PCD_STRUCTURE_PCD_ERROR, "\n".join(MessageGroup) )\r
            else:\r
                EdkLogger.error('Build', COMMAND_FAILURE, 'Can not execute command: %s' % MakeCommand)\r
\r
        if DscBuildData.NeedUpdateOutput(OutputValueFile, PcdValueInitExe, InputValueFile):\r
            Command = PcdValueInitExe + ' -i %s -o %s' % (InputValueFile, OutputValueFile)\r
            returncode, StdOut, StdErr = DscBuildData.ExecuteCommand (Command)\r
            if returncode != 0:\r
                EdkLogger.warn('Build', COMMAND_FAILURE, 'Can not collect output from command: %s' % Command)\r
\r
        File = open (OutputValueFile, 'r')\r
        FileBuffer = File.readlines()\r
        File.close()\r
\r
        StructurePcdSet = []\r
        for Pcd in FileBuffer:\r
            PcdValue = Pcd.split ('|')\r
            PcdInfo = PcdValue[0].split ('.')\r
            StructurePcdSet.append((PcdInfo[0], PcdInfo[1], PcdInfo[2], PcdInfo[3], PcdValue[2].strip()))\r
        return StructurePcdSet\r
\r
    @staticmethod\r
    def NeedUpdateOutput(OutputFile, ValueCFile, StructureInput):\r
        if not os.path.exists(OutputFile):\r
            return True\r
        if os.stat(OutputFile).st_mtime <= os.stat(ValueCFile).st_mtime:\r
            return True\r
        if os.stat(OutputFile).st_mtime <= os.stat(StructureInput).st_mtime:\r
            return True\r
        return False\r
\r
    ## Retrieve dynamic PCD settings\r
    #\r
    #   @param  Type    PCD type\r
    #\r
    #   @retval a dict object contains settings of given PCD type\r
    #\r
    def _GetDynamicPcd(self, Type):\r
\r
\r
        Pcds = OrderedDict()\r
        #\r
        # tdict is a special dict kind of type, used for selecting correct\r
        # PCD settings for certain ARCH and SKU\r
        #\r
        PcdDict = tdict(True, 4)\r
        PcdList = []\r
        # Find out all possible PCD candidates for self._Arch\r
        RecordList = self._RawData[Type, self._Arch]\r
        AvailableSkuIdSet = copy.copy(self.SkuIds)\r
\r
\r
        for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4, Dummy5 in RecordList:\r
            SkuName = SkuName.upper()\r
            SkuName = TAB_DEFAULT if SkuName == TAB_COMMON else SkuName\r
            if SkuName not in AvailableSkuIdSet:\r
                EdkLogger.error('build', PARAMETER_INVALID, 'Sku %s is not defined in [SkuIds] section' % SkuName,\r
                                            File=self.MetaFile, Line=Dummy5)\r
            if "." not in TokenSpaceGuid:\r
                PcdList.append((PcdCName, TokenSpaceGuid, SkuName, Dummy5))\r
            PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid] = Setting\r
\r
        # Remove redundant PCD candidates, per the ARCH and SKU\r
        for PcdCName, TokenSpaceGuid, SkuName, Dummy4 in PcdList:\r
\r
            Setting = PcdDict[self._Arch, SkuName, PcdCName, TokenSpaceGuid]\r
            if Setting is None:\r
                continue\r
\r
            PcdValue, DatumType, MaxDatumSize = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)\r
            SkuInfo = SkuInfoClass(SkuName, self.SkuIds[SkuName][0], '', '', '', '', '', PcdValue)\r
            if (PcdCName, TokenSpaceGuid) in Pcds:\r
                pcdObject = Pcds[PcdCName, TokenSpaceGuid]\r
                pcdObject.SkuInfoList[SkuName] = SkuInfo\r
                if MaxDatumSize.strip():\r
                    CurrentMaxSize = int(MaxDatumSize.strip(), 0)\r
                else:\r
                    CurrentMaxSize = 0\r
                if pcdObject.MaxDatumSize:\r
                    PcdMaxSize = int(pcdObject.MaxDatumSize, 0)\r
                else:\r
                    PcdMaxSize = 0\r
                if CurrentMaxSize > PcdMaxSize:\r
                    pcdObject.MaxDatumSize = str(CurrentMaxSize)\r
            else:\r
                Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(\r
                                                    PcdCName,\r
                                                    TokenSpaceGuid,\r
                                                    self._PCD_TYPE_STRING_[Type],\r
                                                    DatumType,\r
                                                    PcdValue,\r
                                                    '',\r
                                                    MaxDatumSize,\r
                                                    {SkuName : SkuInfo},\r
                                                    False,\r
                                                    None,\r
                                                    IsDsc=True)\r
\r
        for pcd in Pcds.values():\r
            pcdDecObject = self._DecPcds[pcd.TokenCName, pcd.TokenSpaceGuidCName]\r
            # Only fix the value while no value provided in DSC file.\r
            for sku in pcd.SkuInfoList.values():\r
                if not sku.DefaultValue:\r
                    sku.DefaultValue = pcdDecObject.DefaultValue\r
            if TAB_DEFAULT not in pcd.SkuInfoList and TAB_COMMON not in pcd.SkuInfoList:\r
                valuefromDec = pcdDecObject.DefaultValue\r
                SkuInfo = SkuInfoClass(TAB_DEFAULT, '0', '', '', '', '', '', valuefromDec)\r
                pcd.SkuInfoList[TAB_DEFAULT] = SkuInfo\r
            elif TAB_DEFAULT not in pcd.SkuInfoList and TAB_COMMON in pcd.SkuInfoList:\r
                pcd.SkuInfoList[TAB_DEFAULT] = pcd.SkuInfoList[TAB_COMMON]\r
                del pcd.SkuInfoList[TAB_COMMON]\r
            elif TAB_DEFAULT in pcd.SkuInfoList and TAB_COMMON in pcd.SkuInfoList:\r
                del pcd.SkuInfoList[TAB_COMMON]\r
\r
        map(self.FilterSkuSettings, Pcds.values())\r
\r
        return Pcds\r
\r
    def FilterSkuSettings(self, PcdObj):\r
\r
        if self.SkuIdMgr.SkuUsageType == self.SkuIdMgr.SINGLE:\r
            if TAB_DEFAULT in PcdObj.SkuInfoList and self.SkuIdMgr.SystemSkuId not in PcdObj.SkuInfoList:\r
                PcdObj.SkuInfoList[self.SkuIdMgr.SystemSkuId] = PcdObj.SkuInfoList[TAB_DEFAULT]\r
            PcdObj.SkuInfoList = {TAB_DEFAULT:PcdObj.SkuInfoList[self.SkuIdMgr.SystemSkuId]}\r
            PcdObj.SkuInfoList[TAB_DEFAULT].SkuIdName = TAB_DEFAULT\r
            PcdObj.SkuInfoList[TAB_DEFAULT].SkuId = '0'\r
\r
        elif self.SkuIdMgr.SkuUsageType == self.SkuIdMgr.DEFAULT:\r
            PcdObj.SkuInfoList = {TAB_DEFAULT:PcdObj.SkuInfoList[TAB_DEFAULT]}\r
\r
        return PcdObj\r
\r
    @staticmethod\r
    def CompareVarAttr(Attr1, Attr2):\r
        if not Attr1 or not Attr2:  # for empty string\r
            return True\r
        Attr1s = [attr.strip() for attr in Attr1.split(",")]\r
        Attr1Set = set(Attr1s)\r
        Attr2s = [attr.strip() for attr in Attr2.split(",")]\r
        Attr2Set = set(Attr2s)\r
        if Attr2Set == Attr1Set:\r
            return True\r
        else:\r
            return False\r
\r
    def CopyDscRawValue(self, Pcd):\r
        if Pcd.DscRawValue is None:\r
            Pcd.DscRawValue = dict()\r
        if Pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_FIXED_AT_BUILD], self._PCD_TYPE_STRING_[MODEL_PCD_PATCHABLE_IN_MODULE]]:\r
            if self.SkuIdMgr.SystemSkuId not in Pcd.DscRawValue:\r
                Pcd.DscRawValue[self.SkuIdMgr.SystemSkuId] = {}\r
            Pcd.DscRawValue[self.SkuIdMgr.SystemSkuId][TAB_DEFAULT_STORES_DEFAULT] = Pcd.DefaultValue\r
        for skuname in Pcd.SkuInfoList:\r
            Pcd.DscRawValue[skuname] = {}\r
            if Pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:\r
                for defaultstore in Pcd.SkuInfoList[skuname].DefaultStoreDict:\r
                    Pcd.DscRawValue[skuname][defaultstore] = Pcd.SkuInfoList[skuname].DefaultStoreDict[defaultstore]\r
            else:\r
                Pcd.DscRawValue[skuname][TAB_DEFAULT_STORES_DEFAULT] = Pcd.SkuInfoList[skuname].DefaultValue\r
    def CompletePcdValues(self, PcdSet):\r
        Pcds = {}\r
        DefaultStoreObj = DefaultStore(self._GetDefaultStores())\r
        SkuIds = {skuname:skuid for skuname, skuid in self.SkuIdMgr.AvailableSkuIdSet.items() if skuname != TAB_COMMON}\r
        DefaultStores = set(storename for pcdobj in PcdSet.values() for skuobj in pcdobj.SkuInfoList.values() for storename in skuobj.DefaultStoreDict)\r
        for PcdCName, TokenSpaceGuid in PcdSet:\r
            PcdObj = PcdSet[(PcdCName, TokenSpaceGuid)]\r
            self.CopyDscRawValue(PcdObj)\r
            if PcdObj.Type not in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_DEFAULT],\r
                        self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII],\r
                        self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_VPD],\r
                        self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_DEFAULT],\r
                        self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII],\r
                        self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_VPD]]:\r
                Pcds[PcdCName, TokenSpaceGuid]= PcdObj\r
                continue\r
            PcdType = PcdObj.Type\r
            if PcdType in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:\r
                for skuid in PcdObj.SkuInfoList:\r
                    skuobj = PcdObj.SkuInfoList[skuid]\r
                    mindefaultstorename = DefaultStoreObj.GetMin(set(defaultstorename for defaultstorename in skuobj.DefaultStoreDict))\r
                    for defaultstorename in DefaultStores:\r
                        if defaultstorename not in skuobj.DefaultStoreDict:\r
                            skuobj.DefaultStoreDict[defaultstorename] = copy.deepcopy(skuobj.DefaultStoreDict[mindefaultstorename])\r
                    skuobj.HiiDefaultValue = skuobj.DefaultStoreDict[mindefaultstorename]\r
            for skuname, skuid in SkuIds.items():\r
                if skuname not in PcdObj.SkuInfoList:\r
                    nextskuid = self.SkuIdMgr.GetNextSkuId(skuname)\r
                    while nextskuid not in PcdObj.SkuInfoList:\r
                        nextskuid = self.SkuIdMgr.GetNextSkuId(nextskuid)\r
                    PcdObj.SkuInfoList[skuname] = copy.deepcopy(PcdObj.SkuInfoList[nextskuid])\r
                    PcdObj.SkuInfoList[skuname].SkuId = skuid\r
                    PcdObj.SkuInfoList[skuname].SkuIdName = skuname\r
            if PcdType in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:\r
                PcdObj.DefaultValue = PcdObj.SkuInfoList.values()[0].HiiDefaultValue if self.SkuIdMgr.SkuUsageType == self.SkuIdMgr.SINGLE else PcdObj.SkuInfoList[TAB_DEFAULT].HiiDefaultValue\r
            Pcds[PcdCName, TokenSpaceGuid]= PcdObj\r
        return Pcds\r
    ## Retrieve dynamic HII PCD settings\r
    #\r
    #   @param  Type    PCD type\r
    #\r
    #   @retval a dict object contains settings of given PCD type\r
    #\r
    def _GetDynamicHiiPcd(self, Type):\r
\r
        VariableAttrs = {}\r
\r
        Pcds = OrderedDict()\r
        #\r
        # tdict is a special dict kind of type, used for selecting correct\r
        # PCD settings for certain ARCH and SKU\r
        #\r
        PcdDict = tdict(True, 5)\r
        PcdSet = set()\r
        RecordList = self._RawData[Type, self._Arch]\r
        # Find out all possible PCD candidates for self._Arch\r
        AvailableSkuIdSet = copy.copy(self.SkuIds)\r
        DefaultStoresDefine = self._GetDefaultStores()\r
\r
        for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, DefaultStore, Dummy4, Dummy5 in RecordList:\r
            SkuName = SkuName.upper()\r
            SkuName = TAB_DEFAULT if SkuName == TAB_COMMON else SkuName\r
            DefaultStore = DefaultStore.upper()\r
            if DefaultStore == TAB_COMMON:\r
                DefaultStore = TAB_DEFAULT_STORES_DEFAULT\r
            if SkuName not in AvailableSkuIdSet:\r
                EdkLogger.error('build', PARAMETER_INVALID, 'Sku %s is not defined in [SkuIds] section' % SkuName,\r
                                            File=self.MetaFile, Line=Dummy5)\r
            if DefaultStore not in DefaultStoresDefine:\r
                EdkLogger.error('build', PARAMETER_INVALID, 'DefaultStores %s is not defined in [DefaultStores] section' % DefaultStore,\r
                                            File=self.MetaFile, Line=Dummy5)\r
            if "." not in TokenSpaceGuid:\r
                PcdSet.add((PcdCName, TokenSpaceGuid, SkuName, DefaultStore, Dummy5))\r
            PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid, DefaultStore] = Setting\r
\r
\r
        # Remove redundant PCD candidates, per the ARCH and SKU\r
        for PcdCName, TokenSpaceGuid, SkuName, DefaultStore, Dummy4 in PcdSet:\r
\r
            Setting = PcdDict[self._Arch, SkuName, PcdCName, TokenSpaceGuid, DefaultStore]\r
            if Setting is None:\r
                continue\r
            VariableName, VariableGuid, VariableOffset, DefaultValue, VarAttribute = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)\r
\r
            rt, Msg = VariableAttributes.ValidateVarAttributes(VarAttribute)\r
            if not rt:\r
                EdkLogger.error("build", PCD_VARIABLE_ATTRIBUTES_ERROR, "Variable attributes settings for %s is incorrect.\n %s" % (".".join((TokenSpaceGuid, PcdCName)), Msg),\r
                        ExtraData="[%s]" % VarAttribute)\r
            ExceedMax = False\r
            FormatCorrect = True\r
            if VariableOffset.isdigit():\r
                if int(VariableOffset, 10) > 0xFFFF:\r
                    ExceedMax = True\r
            elif variablePattern.match(VariableOffset):\r
                if int(VariableOffset, 16) > 0xFFFF:\r
                    ExceedMax = True\r
            # For Offset written in "A.B"\r
            elif VariableOffset.find('.') > -1:\r
                VariableOffsetList = VariableOffset.split(".")\r
                if not (len(VariableOffsetList) == 2\r
                        and IsValidWord(VariableOffsetList[0])\r
                        and IsValidWord(VariableOffsetList[1])):\r
                    FormatCorrect = False\r
            else:\r
                FormatCorrect = False\r
            if not FormatCorrect:\r
                EdkLogger.error('Build', FORMAT_INVALID, "Invalid syntax or format of the variable offset value is incorrect for %s." % ".".join((TokenSpaceGuid, PcdCName)))\r
\r
            if ExceedMax:\r
                EdkLogger.error('Build', OPTION_VALUE_INVALID, "The variable offset value must not exceed the maximum value of 0xFFFF (UINT16) for %s." % ".".join((TokenSpaceGuid, PcdCName)))\r
            if (VariableName, VariableGuid) not in VariableAttrs:\r
                VariableAttrs[(VariableName, VariableGuid)] = VarAttribute\r
            else:\r
                if not DscBuildData.CompareVarAttr(VariableAttrs[(VariableName, VariableGuid)], VarAttribute):\r
                    EdkLogger.error('Build', PCD_VARIABLE_ATTRIBUTES_CONFLICT_ERROR, "The variable %s.%s for DynamicHii PCDs has conflicting attributes [%s] and [%s] " % (VariableGuid, VariableName, VarAttribute, VariableAttrs[(VariableName, VariableGuid)]))\r
\r
            pcdDecObject = self._DecPcds[PcdCName, TokenSpaceGuid]\r
            if (PcdCName, TokenSpaceGuid) in Pcds:\r
                pcdObject = Pcds[PcdCName, TokenSpaceGuid]\r
                if SkuName in pcdObject.SkuInfoList:\r
                    Skuitem = pcdObject.SkuInfoList[SkuName]\r
                    Skuitem.DefaultStoreDict.update({DefaultStore:DefaultValue})\r
                else:\r
                    SkuInfo = SkuInfoClass(SkuName, self.SkuIds[SkuName][0], VariableName, VariableGuid, VariableOffset, DefaultValue, VariableAttribute=VarAttribute, DefaultStore={DefaultStore:DefaultValue})\r
                    pcdObject.SkuInfoList[SkuName] = SkuInfo\r
            else:\r
                SkuInfo = SkuInfoClass(SkuName, self.SkuIds[SkuName][0], VariableName, VariableGuid, VariableOffset, DefaultValue, VariableAttribute=VarAttribute, DefaultStore={DefaultStore:DefaultValue})\r
                Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(\r
                                                PcdCName,\r
                                                TokenSpaceGuid,\r
                                                self._PCD_TYPE_STRING_[Type],\r
                                                '',\r
                                                DefaultValue,\r
                                                '',\r
                                                '',\r
                                                {SkuName : SkuInfo},\r
                                                False,\r
                                                None,\r
                                                pcdDecObject.validateranges,\r
                                                pcdDecObject.validlists,\r
                                                pcdDecObject.expressions,\r
                                                IsDsc=True)\r
\r
\r
        for pcd in Pcds.values():\r
            SkuInfoObj = pcd.SkuInfoList.values()[0]\r
            pcdDecObject = self._DecPcds[pcd.TokenCName, pcd.TokenSpaceGuidCName]\r
            pcd.DatumType = pcdDecObject.DatumType\r
            # Only fix the value while no value provided in DSC file.\r
            for sku in pcd.SkuInfoList.values():\r
                if (sku.HiiDefaultValue == "" or sku.HiiDefaultValue is None):\r
                    sku.HiiDefaultValue = pcdDecObject.DefaultValue\r
                    for default_store in sku.DefaultStoreDict:\r
                        sku.DefaultStoreDict[default_store]=pcdDecObject.DefaultValue\r
                    pcd.DefaultValue = pcdDecObject.DefaultValue\r
            if TAB_DEFAULT not in pcd.SkuInfoList and TAB_COMMON not in pcd.SkuInfoList:\r
                valuefromDec = pcdDecObject.DefaultValue\r
                SkuInfo = SkuInfoClass(TAB_DEFAULT, '0', SkuInfoObj.VariableName, SkuInfoObj.VariableGuid, SkuInfoObj.VariableOffset, valuefromDec, VariableAttribute=SkuInfoObj.VariableAttribute, DefaultStore={DefaultStore:valuefromDec})\r
                pcd.SkuInfoList[TAB_DEFAULT] = SkuInfo\r
            elif TAB_DEFAULT not in pcd.SkuInfoList and TAB_COMMON in pcd.SkuInfoList:\r
                pcd.SkuInfoList[TAB_DEFAULT] = pcd.SkuInfoList[TAB_COMMON]\r
                del pcd.SkuInfoList[TAB_COMMON]\r
            elif TAB_DEFAULT in pcd.SkuInfoList and TAB_COMMON in pcd.SkuInfoList:\r
                del pcd.SkuInfoList[TAB_COMMON]\r
\r
            if pcd.MaxDatumSize.strip():\r
                MaxSize = int(pcd.MaxDatumSize, 0)\r
            else:\r
                MaxSize = 0\r
            if pcd.DatumType not in TAB_PCD_NUMERIC_TYPES:\r
                for (_, skuobj) in pcd.SkuInfoList.items():\r
                    datalen = 0\r
                    skuobj.HiiDefaultValue = StringToArray(skuobj.HiiDefaultValue)\r
                    datalen = len(skuobj.HiiDefaultValue.split(","))\r
                    if datalen > MaxSize:\r
                        MaxSize = datalen\r
                    for defaultst in skuobj.DefaultStoreDict:\r
                        skuobj.DefaultStoreDict[defaultst] = StringToArray(skuobj.DefaultStoreDict[defaultst])\r
                pcd.DefaultValue = StringToArray(pcd.DefaultValue)\r
                pcd.MaxDatumSize = str(MaxSize)\r
        rt, invalidhii = DscBuildData.CheckVariableNameAssignment(Pcds)\r
        if not rt:\r
            invalidpcd = ",".join(invalidhii)\r
            EdkLogger.error('build', PCD_VARIABLE_INFO_ERROR, Message='The same HII PCD must map to the same EFI variable for all SKUs', File=self.MetaFile, ExtraData=invalidpcd)\r
\r
        map(self.FilterSkuSettings, Pcds.values())\r
\r
        return Pcds\r
\r
    @staticmethod\r
    def CheckVariableNameAssignment(Pcds):\r
        invalidhii = []\r
        for pcdname in Pcds:\r
            pcd = Pcds[pcdname]\r
            varnameset = set(sku.VariableName for (skuid, sku) in pcd.SkuInfoList.items())\r
            if len(varnameset) > 1:\r
                invalidhii.append(".".join((pcdname[1], pcdname[0])))\r
        if len(invalidhii):\r
            return False, invalidhii\r
        else:\r
            return True, []\r
    ## Retrieve dynamic VPD PCD settings\r
    #\r
    #   @param  Type    PCD type\r
    #\r
    #   @retval a dict object contains settings of given PCD type\r
    #\r
    def _GetDynamicVpdPcd(self, Type):\r
\r
\r
        Pcds = OrderedDict()\r
        #\r
        # tdict is a special dict kind of type, used for selecting correct\r
        # PCD settings for certain ARCH and SKU\r
        #\r
        PcdDict = tdict(True, 4)\r
        PcdList = []\r
\r
        # Find out all possible PCD candidates for self._Arch\r
        RecordList = self._RawData[Type, self._Arch]\r
        AvailableSkuIdSet = copy.copy(self.SkuIds)\r
\r
        for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4, Dummy5 in RecordList:\r
            SkuName = SkuName.upper()\r
            SkuName = TAB_DEFAULT if SkuName == TAB_COMMON else SkuName\r
            if SkuName not in AvailableSkuIdSet:\r
                EdkLogger.error('build', PARAMETER_INVALID, 'Sku %s is not defined in [SkuIds] section' % SkuName,\r
                                            File=self.MetaFile, Line=Dummy5)\r
            if "." not in TokenSpaceGuid:\r
                PcdList.append((PcdCName, TokenSpaceGuid, SkuName, Dummy5))\r
            PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid] = Setting\r
\r
        # Remove redundant PCD candidates, per the ARCH and SKU\r
        for PcdCName, TokenSpaceGuid, SkuName, Dummy4 in PcdList:\r
            Setting = PcdDict[self._Arch, SkuName, PcdCName, TokenSpaceGuid]\r
            if Setting is None:\r
                continue\r
            #\r
            # For the VOID* type, it can have optional data of MaxDatumSize and InitialValue\r
            # For the Integer & Boolean type, the optional data can only be InitialValue.\r
            # At this point, we put all the data into the PcdClssObject for we don't know the PCD's datumtype\r
            # until the DEC parser has been called.\r
            #\r
            VpdOffset, MaxDatumSize, InitialValue = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)\r
            SkuInfo = SkuInfoClass(SkuName, self.SkuIds[SkuName][0], '', '', '', '', VpdOffset, InitialValue)\r
            if (PcdCName, TokenSpaceGuid) in Pcds:\r
                pcdObject = Pcds[PcdCName, TokenSpaceGuid]\r
                pcdObject.SkuInfoList[SkuName] = SkuInfo\r
                if MaxDatumSize.strip():\r
                    CurrentMaxSize = int(MaxDatumSize.strip(), 0)\r
                else:\r
                    CurrentMaxSize = 0\r
                if pcdObject.MaxDatumSize:\r
                    PcdMaxSize = int(pcdObject.MaxDatumSize, 0)\r
                else:\r
                    PcdMaxSize = 0\r
                if CurrentMaxSize > PcdMaxSize:\r
                    pcdObject.MaxDatumSize = str(CurrentMaxSize)\r
            else:\r
                Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(\r
                                                PcdCName,\r
                                                TokenSpaceGuid,\r
                                                self._PCD_TYPE_STRING_[Type],\r
                                                '',\r
                                                InitialValue,\r
                                                '',\r
                                                MaxDatumSize,\r
                                                {SkuName : SkuInfo},\r
                                                False,\r
                                                None,\r
                                                IsDsc=True)\r
        for pcd in Pcds.values():\r
            SkuInfoObj = pcd.SkuInfoList.values()[0]\r
            pcdDecObject = self._DecPcds[pcd.TokenCName, pcd.TokenSpaceGuidCName]\r
            pcd.DatumType = pcdDecObject.DatumType\r
            # Only fix the value while no value provided in DSC file.\r
            for sku in pcd.SkuInfoList.values():\r
                if not sku.DefaultValue:\r
                    sku.DefaultValue = pcdDecObject.DefaultValue\r
            if TAB_DEFAULT not in pcd.SkuInfoList and TAB_COMMON not in pcd.SkuInfoList:\r
                valuefromDec = pcdDecObject.DefaultValue\r
                SkuInfo = SkuInfoClass(TAB_DEFAULT, '0', '', '', '', '', SkuInfoObj.VpdOffset, valuefromDec)\r
                pcd.SkuInfoList[TAB_DEFAULT] = SkuInfo\r
            elif TAB_DEFAULT not in pcd.SkuInfoList and TAB_COMMON in pcd.SkuInfoList:\r
                pcd.SkuInfoList[TAB_DEFAULT] = pcd.SkuInfoList[TAB_COMMON]\r
                del pcd.SkuInfoList[TAB_COMMON]\r
            elif TAB_DEFAULT in pcd.SkuInfoList and TAB_COMMON in pcd.SkuInfoList:\r
                del pcd.SkuInfoList[TAB_COMMON]\r
\r
\r
        map(self.FilterSkuSettings, Pcds.values())\r
        return Pcds\r
\r
    ## Add external modules\r
    #\r
    #   The external modules are mostly those listed in FDF file, which don't\r
    # need "build".\r
    #\r
    #   @param  FilePath    The path of module description file\r
    #\r
    def AddModule(self, FilePath):\r
        FilePath = NormPath(FilePath)\r
        if FilePath not in self.Modules:\r
            Module = ModuleBuildClassObject()\r
            Module.MetaFile = FilePath\r
            self.Modules.append(Module)\r
\r
    def _GetToolChainFamily(self):\r
        self._ToolChainFamily = "MSFT"\r
        BuildConfigurationFile = os.path.normpath(os.path.join(GlobalData.gConfDirectory, "target.txt"))\r
        if os.path.isfile(BuildConfigurationFile) == True:\r
            TargetTxt      = TargetTxtClassObject()\r
            TargetTxt.LoadTargetTxtFile(BuildConfigurationFile)\r
            ToolDefinitionFile = TargetTxt.TargetTxtDictionary[DataType.TAB_TAT_DEFINES_TOOL_CHAIN_CONF]\r
            if ToolDefinitionFile == '':\r
                ToolDefinitionFile = "tools_def.txt"\r
                ToolDefinitionFile = os.path.normpath(mws.join(self.WorkspaceDir, 'Conf', ToolDefinitionFile))\r
            if os.path.isfile(ToolDefinitionFile) == True:\r
                ToolDef        = ToolDefClassObject()\r
                ToolDef.LoadToolDefFile(ToolDefinitionFile)\r
                ToolDefinition = ToolDef.ToolsDefTxtDatabase\r
                if TAB_TOD_DEFINES_FAMILY not in ToolDefinition \\r
                   or self._Toolchain not in ToolDefinition[TAB_TOD_DEFINES_FAMILY] \\r
                   or not ToolDefinition[TAB_TOD_DEFINES_FAMILY][self._Toolchain]:\r
                    self._ToolChainFamily = "MSFT"\r
                else:\r
                    self._ToolChainFamily = ToolDefinition[TAB_TOD_DEFINES_FAMILY][self._Toolchain]\r
        return self._ToolChainFamily\r
\r
    ## Add external PCDs\r
    #\r
    #   The external PCDs are mostly those listed in FDF file to specify address\r
    # or offset information.\r
    #\r
    #   @param  Name    Name of the PCD\r
    #   @param  Guid    Token space guid of the PCD\r
    #   @param  Value   Value of the PCD\r
    #\r
    def AddPcd(self, Name, Guid, Value):\r
        if (Name, Guid) not in self.Pcds:\r
            self.Pcds[Name, Guid] = PcdClassObject(Name, Guid, '', '', '', '', '', {}, False, None)\r
        self.Pcds[Name, Guid].DefaultValue = Value\r
    @property\r
    def DecPcds(self):\r
        if self._DecPcds is None:\r
            FdfInfList = []\r
            if GlobalData.gFdfParser:\r
                FdfInfList = GlobalData.gFdfParser.Profile.InfList\r
            PkgSet = set()\r
            for Inf in FdfInfList:\r
                ModuleFile = PathClass(NormPath(Inf), GlobalData.gWorkspace, Arch=self._Arch)\r
                if ModuleFile in self._Modules:\r
                    continue\r
                ModuleData = self._Bdb[ModuleFile, self._Arch, self._Target, self._Toolchain]\r
                PkgSet.update(ModuleData.Packages)\r
            self._DecPcds, self._GuidDict = GetDeclaredPcd(self, self._Bdb, self._Arch, self._Target, self._Toolchain, PkgSet)\r
        return self._DecPcds\r
    _Macros             = property(_GetMacros)\r
    Arch                = property(_GetArch, _SetArch)\r
    Platform            = property(_GetPlatformName)\r
    PlatformName        = property(_GetPlatformName)\r
    Guid                = property(_GetFileGuid)\r
    Version             = property(_GetVersion)\r
    DscSpecification    = property(_GetDscSpec)\r
    OutputDirectory     = property(_GetOutpuDir)\r
    SupArchList         = property(_GetSupArch)\r
    BuildTargets        = property(_GetBuildTarget)\r
    SkuName             = property(_GetSkuName, _SetSkuName)\r
    PcdInfoFlag         = property(_GetPcdInfoFlag)\r
    VarCheckFlag        = property(_GetVarCheckFlag)\r
    FlashDefinition     = property(_GetFdfFile)\r
    Prebuild            = property(_GetPrebuild)\r
    Postbuild           = property(_GetPostbuild)\r
    BuildNumber         = property(_GetBuildNumber)\r
    MakefileName        = property(_GetMakefileName)\r
    BsBaseAddress       = property(_GetBsBaseAddress)\r
    RtBaseAddress       = property(_GetRtBaseAddress)\r
    LoadFixAddress      = property(_GetLoadFixAddress)\r
    RFCLanguages        = property(_GetRFCLanguages)\r
    ISOLanguages        = property(_GetISOLanguages)\r
    VpdToolGuid         = property(_GetVpdToolGuid)\r
    SkuIds              = property(_GetSkuIds)\r
    Modules             = property(_GetModules)\r
    LibraryInstances    = property(_GetLibraryInstances)\r
    LibraryClasses      = property(_GetLibraryClasses)\r
    Pcds                = property(_GetPcds)\r
    BuildOptions        = property(_GetBuildOptions)\r
    ToolChainFamily     = property(_GetToolChainFamily)\r