BaseTools: Support Structure PCD value assignment in DEC/DSC

https://bugzilla.tianocore.org/show_bug.cgi?id=542
This is pure BaseTools enhancement to support PCD with one structure.
User can specify PCD value based on its structure field.

Contributed-under: TianoCore Contribution Agreement 1.1
Signed-off-by: Liming Gao <liming.gao@intel.com>
Reviewed-by: Yonghong Zhu <yonghong.zhu@intel.com>

1 files changed, 462 insertions, 0 deletions

diff --git a/BaseTools/Source/Python/Workspace/DecBuildData.py b/BaseTools/Source/Python/Workspace/DecBuildData.py
new file mode 100644
index 0000000000..d0e77fa440
--- /dev/null
+++ b/BaseTools/Source/Python/Workspace/DecBuildData.py
@@ -0,0 +1,462 @@
+## @file

+# This file is used to create a database used by build tool

+#

+# Copyright (c) 2017, Intel Corporation. All rights reserved.<BR>

+# (C) Copyright 2016 Hewlett Packard Enterprise Development LP<BR>

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+from Common.String import *

+from Common.DataType import *

+from Common.Misc import *

+from types import *

+

+from Workspace.BuildClassObject import PackageBuildClassObject, StructurePcd, PcdClassObject

+

+## Platform build information from DEC file

+#

+#  This class is used to retrieve information stored in database and convert them

+# into PackageBuildClassObject form for easier use for AutoGen.

+#

+class DecBuildData(PackageBuildClassObject):

+    # dict used to convert PCD type in database to string used by build tool

+    _PCD_TYPE_STRING_ = {

+        MODEL_PCD_FIXED_AT_BUILD        :   "FixedAtBuild",

+        MODEL_PCD_PATCHABLE_IN_MODULE   :   "PatchableInModule",

+        MODEL_PCD_FEATURE_FLAG          :   "FeatureFlag",

+        MODEL_PCD_DYNAMIC               :   "Dynamic",

+        MODEL_PCD_DYNAMIC_DEFAULT       :   "Dynamic",

+        MODEL_PCD_DYNAMIC_HII           :   "DynamicHii",

+        MODEL_PCD_DYNAMIC_VPD           :   "DynamicVpd",

+        MODEL_PCD_DYNAMIC_EX            :   "DynamicEx",

+        MODEL_PCD_DYNAMIC_EX_DEFAULT    :   "DynamicEx",

+        MODEL_PCD_DYNAMIC_EX_HII        :   "DynamicExHii",

+        MODEL_PCD_DYNAMIC_EX_VPD        :   "DynamicExVpd",

+    }

+

+    # dict used to convert part of [Defines] to members of DecBuildData directly

+    _PROPERTY_ = {

+        #

+        # Required Fields

+        #

+        TAB_DEC_DEFINES_PACKAGE_NAME                : "_PackageName",

+        TAB_DEC_DEFINES_PACKAGE_GUID                : "_Guid",

+        TAB_DEC_DEFINES_PACKAGE_VERSION             : "_Version",

+        TAB_DEC_DEFINES_PKG_UNI_FILE                : "_PkgUniFile",

+    }

+

+

+    ## Constructor of DecBuildData

+    #

+    #  Initialize object of DecBuildData

+    #

+    #   @param      FilePath        The path of package description file

+    #   @param      RawData         The raw data of DEC file

+    #   @param      BuildDataBase   Database used to retrieve module information

+    #   @param      Arch            The target architecture

+    #   @param      Platform        (not used for DecBuildData)

+    #   @param      Macros          Macros used for replacement in DSC file

+    #

+    def __init__(self, File, RawData, BuildDataBase, Arch='COMMON', Target=None, Toolchain=None):

+        self.MetaFile = File

+        self._PackageDir = File.Dir

+        self._RawData = RawData

+        self._Bdb = BuildDataBase

+        self._Arch = Arch

+        self._Target = Target

+        self._Toolchain = Toolchain

+        self._Clear()

+

+    ## XXX[key] = value

+    def __setitem__(self, key, value):

+        self.__dict__[self._PROPERTY_[key]] = value

+

+    ## value = XXX[key]

+    def __getitem__(self, key):

+        return self.__dict__[self._PROPERTY_[key]]

+

+    ## "in" test support

+    def __contains__(self, key):

+        return key in self._PROPERTY_

+

+    ## Set all internal used members of DecBuildData to None

+    def _Clear(self):

+        self._Header            = None

+        self._PackageName       = None

+        self._Guid              = None

+        self._Version           = None

+        self._PkgUniFile        = None

+        self._Protocols         = None

+        self._Ppis              = None

+        self._Guids             = None

+        self._Includes          = None

+        self._LibraryClasses    = None

+        self._Pcds              = None

+        self.__Macros           = None

+        self._PrivateProtocols  = None

+        self._PrivatePpis       = None

+        self._PrivateGuids      = None

+        self._PrivateIncludes   = None

+

+    ## Get current effective macros

+    def _GetMacros(self):

+        if self.__Macros == None:

+            self.__Macros = {}

+            self.__Macros.update(GlobalData.gGlobalDefines)

+        return self.__Macros

+

+    ## Get architecture

+    def _GetArch(self):

+        return self._Arch

+

+    ## Set architecture

+    #

+    #   Changing the default ARCH to another may affect all other information

+    # because all information in a platform may be ARCH-related. That's

+    # why we need to clear all internal used members, in order to cause all

+    # information to be re-retrieved.

+    #

+    #   @param  Value   The value of ARCH

+    #

+    def _SetArch(self, Value):

+        if self._Arch == Value:

+            return

+        self._Arch = Value

+        self._Clear()

+

+    ## Retrieve all information in [Defines] section

+    #

+    #   (Retriving all [Defines] information in one-shot is just to save time.)

+    #

+    def _GetHeaderInfo(self):

+        RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch]

+        for Record in RecordList:

+            Name = Record[1]

+            if Name in self:

+                self[Name] = Record[2]

+        self._Header = 'DUMMY'

+

+    ## Retrieve package name

+    def _GetPackageName(self):

+        if self._PackageName == None:

+            if self._Header == None:

+                self._GetHeaderInfo()

+            if self._PackageName == None:

+                EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, "No PACKAGE_NAME", File=self.MetaFile)

+        return self._PackageName

+

+    ## Retrieve file guid

+    def _GetFileGuid(self):

+        if self._Guid == None:

+            if self._Header == None:

+                self._GetHeaderInfo()

+            if self._Guid == None:

+                EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, "No PACKAGE_GUID", File=self.MetaFile)

+        return self._Guid

+

+    ## Retrieve package version

+    def _GetVersion(self):

+        if self._Version == None:

+            if self._Header == None:

+                self._GetHeaderInfo()

+            if self._Version == None:

+                self._Version = ''

+        return self._Version

+

+    ## Retrieve protocol definitions (name/value pairs)

+    def _GetProtocol(self):

+        if self._Protocols == None:

+            #

+            # tdict is a special kind of dict, used for selecting correct

+            # protocol defition for given ARCH

+            #

+            ProtocolDict = tdict(True)

+            PrivateProtocolDict = tdict(True)

+            NameList = []

+            PrivateNameList = []

+            PublicNameList = []

+            # find out all protocol definitions for specific and 'common' arch

+            RecordList = self._RawData[MODEL_EFI_PROTOCOL, self._Arch]

+            for Name, Guid, Dummy, Arch, PrivateFlag, ID, LineNo in RecordList:

+                if PrivateFlag == 'PRIVATE':

+                    if Name not in PrivateNameList:

+                        PrivateNameList.append(Name)

+                        PrivateProtocolDict[Arch, Name] = Guid

+                    if Name in PublicNameList:

+                        EdkLogger.error('build', OPTION_CONFLICT, "Can't determine %s's attribute, it is both defined as Private and non-Private attribute in DEC file." % Name, File=self.MetaFile, Line=LineNo)

+                else:

+                    if Name not in PublicNameList:

+                        PublicNameList.append(Name)

+                    if Name in PrivateNameList:

+                        EdkLogger.error('build', OPTION_CONFLICT, "Can't determine %s's attribute, it is both defined as Private and non-Private attribute in DEC file." % Name, File=self.MetaFile, Line=LineNo)

+                if Name not in NameList:

+                    NameList.append(Name)

+                ProtocolDict[Arch, Name] = Guid

+            # use sdict to keep the order

+            self._Protocols = sdict()

+            self._PrivateProtocols = sdict()

+            for Name in NameList:

+                #

+                # limit the ARCH to self._Arch, if no self._Arch found, tdict

+                # will automatically turn to 'common' ARCH for trying

+                #

+                self._Protocols[Name] = ProtocolDict[self._Arch, Name]

+            for Name in PrivateNameList:

+                self._PrivateProtocols[Name] = PrivateProtocolDict[self._Arch, Name]

+        return self._Protocols

+

+    ## Retrieve PPI definitions (name/value pairs)

+    def _GetPpi(self):

+        if self._Ppis == None:

+            #

+            # tdict is a special kind of dict, used for selecting correct

+            # PPI defition for given ARCH

+            #

+            PpiDict = tdict(True)

+            PrivatePpiDict = tdict(True)

+            NameList = []

+            PrivateNameList = []

+            PublicNameList = []

+            # find out all PPI definitions for specific arch and 'common' arch

+            RecordList = self._RawData[MODEL_EFI_PPI, self._Arch]

+            for Name, Guid, Dummy, Arch, PrivateFlag, ID, LineNo in RecordList:

+                if PrivateFlag == 'PRIVATE':

+                    if Name not in PrivateNameList:

+                        PrivateNameList.append(Name)

+                        PrivatePpiDict[Arch, Name] = Guid

+                    if Name in PublicNameList:

+                        EdkLogger.error('build', OPTION_CONFLICT, "Can't determine %s's attribute, it is both defined as Private and non-Private attribute in DEC file." % Name, File=self.MetaFile, Line=LineNo)

+                else:

+                    if Name not in PublicNameList:

+                        PublicNameList.append(Name)

+                    if Name in PrivateNameList:

+                        EdkLogger.error('build', OPTION_CONFLICT, "Can't determine %s's attribute, it is both defined as Private and non-Private attribute in DEC file." % Name, File=self.MetaFile, Line=LineNo)

+                if Name not in NameList:

+                    NameList.append(Name)

+                PpiDict[Arch, Name] = Guid

+            # use sdict to keep the order

+            self._Ppis = sdict()

+            self._PrivatePpis = sdict()

+            for Name in NameList:

+                #

+                # limit the ARCH to self._Arch, if no self._Arch found, tdict

+                # will automatically turn to 'common' ARCH for trying

+                #

+                self._Ppis[Name] = PpiDict[self._Arch, Name]

+            for Name in PrivateNameList:

+                self._PrivatePpis[Name] = PrivatePpiDict[self._Arch, Name]

+        return self._Ppis

+

+    ## Retrieve GUID definitions (name/value pairs)

+    def _GetGuid(self):

+        if self._Guids == None:

+            #

+            # tdict is a special kind of dict, used for selecting correct

+            # GUID defition for given ARCH

+            #

+            GuidDict = tdict(True)

+            PrivateGuidDict = tdict(True)

+            NameList = []

+            PrivateNameList = []

+            PublicNameList = []

+            # find out all protocol definitions for specific and 'common' arch

+            RecordList = self._RawData[MODEL_EFI_GUID, self._Arch]

+            for Name, Guid, Dummy, Arch, PrivateFlag, ID, LineNo in RecordList:

+                if PrivateFlag == 'PRIVATE':

+                    if Name not in PrivateNameList:

+                        PrivateNameList.append(Name)

+                        PrivateGuidDict[Arch, Name] = Guid

+                    if Name in PublicNameList:

+                        EdkLogger.error('build', OPTION_CONFLICT, "Can't determine %s's attribute, it is both defined as Private and non-Private attribute in DEC file." % Name, File=self.MetaFile, Line=LineNo)

+                else:

+                    if Name not in PublicNameList:

+                        PublicNameList.append(Name)

+                    if Name in PrivateNameList:

+                        EdkLogger.error('build', OPTION_CONFLICT, "Can't determine %s's attribute, it is both defined as Private and non-Private attribute in DEC file." % Name, File=self.MetaFile, Line=LineNo)

+                if Name not in NameList:

+                    NameList.append(Name)

+                GuidDict[Arch, Name] = Guid

+            # use sdict to keep the order

+            self._Guids = sdict()

+            self._PrivateGuids = sdict()

+            for Name in NameList:

+                #

+                # limit the ARCH to self._Arch, if no self._Arch found, tdict

+                # will automatically turn to 'common' ARCH for trying

+                #

+                self._Guids[Name] = GuidDict[self._Arch, Name]

+            for Name in PrivateNameList:

+                self._PrivateGuids[Name] = PrivateGuidDict[self._Arch, Name]

+        return self._Guids

+

+    ## Retrieve public include paths declared in this package

+    def _GetInclude(self):

+        if self._Includes == None:

+            self._Includes = []

+            self._PrivateIncludes = []

+            PublicInclues = []

+            RecordList = self._RawData[MODEL_EFI_INCLUDE, self._Arch]

+            Macros = self._Macros

+            Macros["EDK_SOURCE"] = GlobalData.gEcpSource

+            for Record in RecordList:

+                File = PathClass(NormPath(Record[0], Macros), self._PackageDir, Arch=self._Arch)

+                LineNo = Record[-1]

+                # validate the path

+                ErrorCode, ErrorInfo = File.Validate()

+                if ErrorCode != 0:

+                    EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo)

+

+                # avoid duplicate include path

+                if File not in self._Includes:

+                    self._Includes.append(File)

+                if Record[4] == 'PRIVATE':

+                    if File not in self._PrivateIncludes:

+                        self._PrivateIncludes.append(File)

+                    if File in PublicInclues:

+                        EdkLogger.error('build', OPTION_CONFLICT, "Can't determine %s's attribute, it is both defined as Private and non-Private attribute in DEC file." % File, File=self.MetaFile, Line=LineNo)

+                else:

+                    if File not in PublicInclues:

+                        PublicInclues.append(File)

+                    if File in self._PrivateIncludes:

+                        EdkLogger.error('build', OPTION_CONFLICT, "Can't determine %s's attribute, it is both defined as Private and non-Private attribute in DEC file." % File, File=self.MetaFile, Line=LineNo)

+

+        return self._Includes

+

+    ## Retrieve library class declarations (not used in build at present)

+    def _GetLibraryClass(self):

+        if self._LibraryClasses == None:

+            #

+            # tdict is a special kind of dict, used for selecting correct

+            # library class declaration for given ARCH

+            #

+            LibraryClassDict = tdict(True)

+            LibraryClassSet = set()

+            RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch]

+            Macros = self._Macros

+            for LibraryClass, File, Dummy, Arch, PrivateFlag, ID, LineNo in RecordList:

+                File = PathClass(NormPath(File, Macros), self._PackageDir, Arch=self._Arch)

+                # check the file validation

+                ErrorCode, ErrorInfo = File.Validate()

+                if ErrorCode != 0:

+                    EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo)

+                LibraryClassSet.add(LibraryClass)

+                LibraryClassDict[Arch, LibraryClass] = File

+            self._LibraryClasses = sdict()

+            for LibraryClass in LibraryClassSet:

+                self._LibraryClasses[LibraryClass] = LibraryClassDict[self._Arch, LibraryClass]

+        return self._LibraryClasses

+

+    ## Retrieve PCD declarations

+    def _GetPcds(self):

+        if self._Pcds == None:

+            self._Pcds = sdict()

+            self._Pcds.update(self._GetPcd(MODEL_PCD_FIXED_AT_BUILD))

+            self._Pcds.update(self._GetPcd(MODEL_PCD_PATCHABLE_IN_MODULE))

+            self._Pcds.update(self._GetPcd(MODEL_PCD_FEATURE_FLAG))

+            self._Pcds.update(self._GetPcd(MODEL_PCD_DYNAMIC))

+            self._Pcds.update(self._GetPcd(MODEL_PCD_DYNAMIC_EX))

+        return self._Pcds

+

+

+    def ProcessStructurePcd(self, StructurePcdRawDataSet):

+        s_pcd_set = dict()

+        for s_pcd,LineNo in StructurePcdRawDataSet:

+            if s_pcd.TokenSpaceGuidCName not in s_pcd_set:

+                s_pcd_set[s_pcd.TokenSpaceGuidCName] = []

+            s_pcd_set[s_pcd.TokenSpaceGuidCName].append((s_pcd,LineNo))

+

+        str_pcd_set = []

+        for pcdname in s_pcd_set:

+            dep_pkgs = []

+            struct_pcd = StructurePcd()

+            for item,LineNo in s_pcd_set[pcdname]:

+                if "<HeaderFiles>" in item.TokenCName:

+                    struct_pcd.StructuredPcdIncludeFile = item.DefaultValue

+                elif "<Packages>" in item.TokenCName:

+                    dep_pkgs.append(item.DefaultValue)

+                elif item.DatumType == item.TokenCName:

+                    struct_pcd.copy(item)

+                    struct_pcd.TokenValue = struct_pcd.TokenValue.strip("{").strip()

+                    struct_pcd.TokenSpaceGuidCName, struct_pcd.TokenCName = pcdname.split(".")

+                else:

+                    struct_pcd.AddDefaultValue(item.TokenCName, item.DefaultValue,self.MetaFile.File,LineNo)

+

+            struct_pcd.PackageDecs = dep_pkgs

+

+            str_pcd_set.append(struct_pcd)

+

+        return str_pcd_set

+

+    ## Retrieve PCD declarations for given type

+    def _GetPcd(self, Type):

+        Pcds = sdict()

+        #

+        # tdict is a special kind of dict, used for selecting correct

+        # PCD declaration for given ARCH

+        #

+        PcdDict = tdict(True, 3)

+        # for summarizing PCD

+        PcdSet = set()

+        # find out all PCDs of the 'type'

+

+        StrPcdSet = []

+        RecordList = self._RawData[Type, self._Arch]

+        for TokenSpaceGuid, PcdCName, Setting, Arch, PrivateFlag, Dummy1, Dummy2 in RecordList:

+            PcdDict[Arch, PcdCName, TokenSpaceGuid] = (Setting,Dummy2)

+            PcdSet.add((PcdCName, TokenSpaceGuid))

+

+        for PcdCName, TokenSpaceGuid in PcdSet:

+            #

+            # limit the ARCH to self._Arch, if no self._Arch found, tdict

+            # will automatically turn to 'common' ARCH and try again

+            #

+            Setting,LineNo = PcdDict[self._Arch, PcdCName, TokenSpaceGuid]

+            if Setting == None:

+                continue

+

+            DefaultValue, DatumType, TokenNumber = AnalyzePcdData(Setting)

+            validateranges, validlists, expressions = self._RawData.GetValidExpression(TokenSpaceGuid, PcdCName)

+            PcdObj = PcdClassObject(

+                                        PcdCName,

+                                        TokenSpaceGuid,

+                                        self._PCD_TYPE_STRING_[Type],

+                                        DatumType,

+                                        DefaultValue,

+                                        TokenNumber,

+                                        '',

+                                        {},

+                                        False,

+                                        None,

+                                        list(validateranges),

+                                        list(validlists),

+                                        list(expressions)

+                                        )

+            if "." in TokenSpaceGuid:

+                StrPcdSet.append((PcdObj,LineNo))

+            else:

+                Pcds[PcdCName, TokenSpaceGuid, self._PCD_TYPE_STRING_[Type]] = PcdObj

+

+        StructurePcds = self.ProcessStructurePcd(StrPcdSet)

+        for pcd in StructurePcds:

+            Pcds[pcd.TokenCName, pcd.TokenSpaceGuidCName, self._PCD_TYPE_STRING_[Type]] = pcd

+

+        return Pcds

+

+

+    _Macros = property(_GetMacros)

+    Arch = property(_GetArch, _SetArch)

+    PackageName = property(_GetPackageName)

+    Guid = property(_GetFileGuid)

+    Version = property(_GetVersion)

+

+    Protocols = property(_GetProtocol)

+    Ppis = property(_GetPpi)

+    Guids = property(_GetGuid)

+    Includes = property(_GetInclude)

+    LibraryClasses = property(_GetLibraryClass)

+    Pcds = property(_GetPcds)