BaseTools/Source/Python/Workspace/BuildClassObject.py

   1 ## @file
   2 # This file is used to define each component of the build database
   3 #
   4 # Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>
   5 # SPDX-License-Identifier: BSD-2-Clause-Patent
   6 #
   7
   8 from collections import OrderedDict, namedtuple
   9 from Common.DataType import *
  10 import collections
  11 import re
  12 from collections import OrderedDict
  13 from Common.Misc import CopyDict,ArrayIndex
  14 import copy
  15 from CommonDataClass.DataClass import *
  16 import Common.EdkLogger as EdkLogger
  17 import Common.GlobalData as GlobalData
  18 from Common.BuildToolError import OPTION_VALUE_INVALID
  19 from Common.caching import cached_property
  20 StructPattern = re.compile(r'[_a-zA-Z][0-9A-Za-z_\[\]]*$')
  21
  22 ## PcdClassObject
  23 #
  24 # This Class is used for PcdObject
  25 #
  26 # @param object:             Inherited from object class
  27 # @param Name:               Input value for Name of Pcd, default is None
  28 # @param Guid:               Input value for Guid of Pcd, default is None
  29 # @param Type:               Input value for Type of Pcd, default is None
  30 # @param DatumType:          Input value for DatumType of Pcd, default is None
  31 # @param Value:              Input value for Value of Pcd, default is None
  32 # @param Token:              Input value for Token of Pcd, default is None
  33 # @param MaxDatumSize:       Input value for MaxDatumSize of Pcd, default is None
  34 # @param SkuInfoList:        Input value for SkuInfoList of Pcd, default is {}
  35 # @param IsOverrided:        Input value for IsOverrided of Pcd, default is False
  36 # @param GuidValue:          Input value for TokenSpaceGuidValue of Pcd, default is None
  37 #
  38 # @var TokenCName:           To store value for TokenCName
  39 # @var TokenSpaceGuidCName:  To store value for TokenSpaceGuidCName
  40 # @var Type:                 To store value for Type
  41 # @var DatumType:            To store value for DatumType
  42 # @var TokenValue:           To store value for TokenValue
  43 # @var MaxDatumSize:         To store value for MaxDatumSize
  44 # @var SkuInfoList:          To store value for SkuInfoList
  45 # @var IsOverrided:          To store value for IsOverrided
  46 # @var Phase:                To store value for Phase, default is "DXE"
  47 #
  48 class PcdClassObject(object):
  49     def __init__(self, Name = None, Guid = None, Type = None, DatumType = None, Value = None, Token = None, MaxDatumSize = None, SkuInfoList = None, IsOverrided = False, GuidValue = None, validateranges = None, validlists = None, expressions = None, IsDsc = False, UserDefinedDefaultStoresFlag = False):
  50         self.TokenCName = Name
  51         self.TokenSpaceGuidCName = Guid
  52         self.TokenSpaceGuidValue = GuidValue
  53         self.Type = Type
  54         self._DatumType = DatumType
  55         self.DefaultValue = Value
  56         self.TokenValue = Token
  57         self.MaxDatumSize = MaxDatumSize
  58         self.MaxSizeUserSet = None
  59         self.SkuInfoList = SkuInfoList if SkuInfoList is not None else OrderedDict()
  60         self.Phase = "DXE"
  61         self.Pending = False
  62         self.IsOverrided = IsOverrided
  63         self.IsFromBinaryInf = False
  64         self.IsFromDsc = False
  65         self.validateranges = validateranges if validateranges is not None else []
  66         self.validlists = validlists if validlists is not None else []
  67         self.expressions = expressions if expressions is not None else []
  68         self.DscDefaultValue = None
  69         self.DscRawValue = {}
  70         self.DscRawValueInfo = {}
  71         if IsDsc:
  72             self.DscDefaultValue = Value
  73         self.PcdValueFromComm = ""
  74         self.PcdValueFromFdf = ""
  75         self.PcdValueFromComponents = {} #{ModuleGuid:value, file_path,lineNo}
  76         self.CustomAttribute = {}
  77         self.UserDefinedDefaultStoresFlag = UserDefinedDefaultStoresFlag
  78         self._Capacity = None
  79
  80     @property
  81     def Capacity(self):
  82         if self._Capacity is None:
  83             self._Capacity = []
  84             dimension = ArrayIndex.findall(self._DatumType)
  85             for item in dimension:
  86                 maxsize = item.lstrip("[").rstrip("]").strip()
  87                 if not maxsize:
  88                     maxsize = "-1"
  89                 maxsize = str(int(maxsize,16)) if maxsize.startswith(("0x","0X")) else maxsize
  90                 self._Capacity.append(maxsize)
  91             if hasattr(self, "SkuOverrideValues"):
  92                 for sku in self.SkuOverrideValues:
  93                     for defaultstore in self.SkuOverrideValues[sku]:
  94                         fields = self.SkuOverrideValues[sku][defaultstore]
  95                         for demesionattr in fields:
  96                             fieldinfo = fields[demesionattr]
  97                             deme = ArrayIndex.findall(demesionattr)
  98                             for i in range(len(deme)):
  99                                 if int(deme[i].lstrip("[").rstrip("]").strip()) >= int(self._Capacity[i]):
 100                                     if self._Capacity[i] != "-1":
 101                                         firstfieldinfo = list(fieldinfo.values())[0]
 102                                         EdkLogger.error('Build', OPTION_VALUE_INVALID, "For Pcd %s, Array Index exceed the Array size. From %s Line %s \n " %
 103                                     (".".join((self.TokenSpaceGuidCName, self.TokenCName)), firstfieldinfo[1],firstfieldinfo[2] ))
 104             if hasattr(self,"DefaultValues"):
 105                 for demesionattr in self.DefaultValues:
 106                     fieldinfo = self.DefaultValues[demesionattr]
 107                     deme = ArrayIndex.findall(demesionattr)
 108                     for i in range(len(deme)):
 109                         if int(deme[i].lstrip("[").rstrip("]").strip()) >= int(self._Capacity[i]):
 110                             if self._Capacity[i] != "-1":
 111                                 firstfieldinfo = list(fieldinfo.values())[0]
 112                                 EdkLogger.error('Build', OPTION_VALUE_INVALID, "For Pcd %s, Array Index exceed the Array size. From %s Line %s \n " %
 113                                     (".".join((self.TokenSpaceGuidCName, self.TokenCName)), firstfieldinfo[1],firstfieldinfo[2] ))
 114         return self._Capacity
 115
 116     def PcdArraySize(self):
 117         if self.Capacity[-1] == "-1":
 118             return -1
 119         size = 1
 120         for de in self.Capacity:
 121             size = size * int(de)
 122         return size
 123     @property
 124     def DatumType(self):
 125         return self._DatumType
 126
 127     @DatumType.setter
 128     def DatumType(self,DataType):
 129         self._DatumType = DataType
 130         self._Capacity = None
 131
 132     @property
 133     def BaseDatumType(self):
 134         if self.IsArray():
 135             return self._DatumType[:self._DatumType.index("[")]
 136         else:
 137             return self._DatumType
 138     def IsArray(self):
 139         return True if len(self.Capacity) else False
 140
 141     def IsAggregateDatumType(self):
 142         if self.DatumType in [TAB_UINT8, TAB_UINT16, TAB_UINT32, TAB_UINT64, TAB_VOID, "BOOLEAN"]:
 143             return False
 144         if self.IsArray() or StructPattern.match(self.DatumType):
 145             return True
 146         return False
 147
 148     def IsSimpleTypeArray(self):
 149         if self.IsArray() and self.BaseDatumType in [TAB_UINT8, TAB_UINT16, TAB_UINT32, TAB_UINT64, "BOOLEAN"]:
 150             return True
 151         return False
 152
 153     @staticmethod
 154     def GetPcdMaxSizeWorker(PcdString, MaxSize):
 155         if PcdString.startswith("{") and PcdString.endswith("}"):
 156             return  max([len(PcdString.split(",")),MaxSize])
 157
 158         if PcdString.startswith("\"") or PcdString.startswith("\'"):
 159             return  max([len(PcdString)-2+1,MaxSize])
 160
 161         if PcdString.startswith("L\""):
 162             return  max([2*(len(PcdString)-3+1),MaxSize])
 163
 164         return max([len(PcdString),MaxSize])
 165
 166     ## Get the maximum number of bytes
 167     def GetPcdMaxSize(self):
 168         if self.DatumType in TAB_PCD_NUMERIC_TYPES:
 169             return MAX_SIZE_TYPE[self.DatumType]
 170
 171         MaxSize = int(self.MaxDatumSize, 10) if self.MaxDatumSize else 0
 172         if self.PcdValueFromFdf:
 173             MaxSize = self.GetPcdMaxSizeWorker(self.PcdValueFromFdf,MaxSize)
 174         if self.PcdValueFromComm:
 175             MaxSize = self.GetPcdMaxSizeWorker(self.PcdValueFromComm,MaxSize)
 176         if hasattr(self, "DefaultValueFromDec"):
 177             MaxSize = self.GetPcdMaxSizeWorker(self.DefaultValueFromDec,MaxSize)
 178         return MaxSize
 179
 180     ## Get the number of bytes
 181     def GetPcdSize(self):
 182         if self.DatumType in TAB_PCD_NUMERIC_TYPES:
 183             return MAX_SIZE_TYPE[self.DatumType]
 184         if not self.DefaultValue:
 185             return 1
 186         elif self.DefaultValue[0] == 'L':
 187             return (len(self.DefaultValue) - 2) * 2
 188         elif self.DefaultValue[0] == '{':
 189             return len(self.DefaultValue.split(','))
 190         else:
 191             return len(self.DefaultValue) - 1
 192
 193
 194     ## Convert the class to a string
 195     #
 196     #  Convert each member of the class to string
 197     #  Organize to a single line format string
 198     #
 199     #  @retval Rtn Formatted String
 200     #
 201     def __str__(self):
 202         Rtn = '\tTokenCName=' + str(self.TokenCName) + ', ' + \
 203               'TokenSpaceGuidCName=' + str(self.TokenSpaceGuidCName) + ', ' + \
 204               'Type=' + str(self.Type) + ', ' + \
 205               'DatumType=' + str(self.DatumType) + ', ' + \
 206               'DefaultValue=' + str(self.DefaultValue) + ', ' + \
 207               'TokenValue=' + str(self.TokenValue) + ', ' + \
 208               'MaxDatumSize=' + str(self.MaxDatumSize) + ', '
 209         for Item in self.SkuInfoList.values():
 210             Rtn = Rtn + 'SkuId=' + Item.SkuId + ', ' + 'SkuIdName=' + Item.SkuIdName
 211         Rtn = Rtn + ', IsOverrided=' + str(self.IsOverrided)
 212
 213         return Rtn
 214
 215     ## Override __eq__ function
 216     #
 217     # Check whether pcds are the same
 218     #
 219     # @retval False The two pcds are different
 220     # @retval True  The two pcds are the same
 221     #
 222     def __eq__(self, Other):
 223         return Other and self.TokenCName == Other.TokenCName and self.TokenSpaceGuidCName == Other.TokenSpaceGuidCName
 224
 225     ## Override __hash__ function
 226     #
 227     # Use (TokenCName, TokenSpaceGuidCName) as key in hash table
 228     #
 229     # @retval truple() Key for hash table
 230     #
 231     def __hash__(self):
 232         return hash((self.TokenCName, self.TokenSpaceGuidCName))
 233
 234     @cached_property
 235     def _fullname(self):
 236         return ".".join((self.TokenSpaceGuidCName,self.TokenCName))
 237
 238     def __lt__(self,pcd):
 239         return self._fullname < pcd._fullname
 240     def __gt__(self,pcd):
 241         return self._fullname > pcd._fullname
 242
 243     def sharedcopy(self,new_pcd):
 244         new_pcd.TokenCName = self.TokenCName
 245         new_pcd.TokenSpaceGuidCName = self.TokenSpaceGuidCName
 246         new_pcd.TokenSpaceGuidValue = self.TokenSpaceGuidValue
 247         new_pcd.Type = self.Type
 248         new_pcd.DatumType = self.DatumType
 249         new_pcd.DefaultValue = self.DefaultValue
 250         new_pcd.TokenValue = self.TokenValue
 251         new_pcd.MaxDatumSize = self.MaxDatumSize
 252         new_pcd.MaxSizeUserSet = self.MaxSizeUserSet
 253
 254         new_pcd.Phase = self.Phase
 255         new_pcd.Pending = self.Pending
 256         new_pcd.IsOverrided = self.IsOverrided
 257         new_pcd.IsFromBinaryInf = self.IsFromBinaryInf
 258         new_pcd.IsFromDsc = self.IsFromDsc
 259         new_pcd.PcdValueFromComm = self.PcdValueFromComm
 260         new_pcd.PcdValueFromFdf = self.PcdValueFromFdf
 261         new_pcd.UserDefinedDefaultStoresFlag = self.UserDefinedDefaultStoresFlag
 262         new_pcd.DscRawValue = self.DscRawValue
 263         new_pcd.DscRawValueInfo = self.DscRawValueInfo
 264         new_pcd.CustomAttribute = self.CustomAttribute
 265         new_pcd.validateranges = [item for item in self.validateranges]
 266         new_pcd.validlists = [item for item in self.validlists]
 267         new_pcd.expressions = [item for item in self.expressions]
 268         new_pcd.SkuInfoList = {key: copy.deepcopy(skuobj) for key,skuobj in self.SkuInfoList.items()}
 269         return new_pcd
 270
 271     def __deepcopy__(self,memo):
 272         new_pcd = PcdClassObject()
 273         self.sharedcopy(new_pcd)
 274         return new_pcd
 275
 276 class StructurePcd(PcdClassObject):
 277     def __init__(self, StructuredPcdIncludeFile=None, Packages=None, Name=None, Guid=None, Type=None, DatumType=None, Value=None, Token=None, MaxDatumSize=None, SkuInfoList=None, IsOverrided=False, GuidValue=None, validateranges=None, validlists=None, expressions=None,default_store = TAB_DEFAULT_STORES_DEFAULT):
 278         if SkuInfoList is None:
 279             SkuInfoList = {}
 280         if validateranges is None:
 281             validateranges = []
 282         if validlists is None:
 283             validlists = []
 284         if expressions is None:
 285             expressions = []
 286         if Packages is None:
 287             Packages = []
 288         super(StructurePcd, self).__init__(Name, Guid, Type, DatumType, Value, Token, MaxDatumSize, SkuInfoList, IsOverrided, GuidValue, validateranges, validlists, expressions)
 289         self.StructuredPcdIncludeFile = [] if StructuredPcdIncludeFile is None else StructuredPcdIncludeFile
 290         self.PackageDecs = Packages
 291         self.DefaultStoreName = [default_store]
 292         self.DefaultValues = OrderedDict()
 293         self.PcdMode = None
 294         self.SkuOverrideValues = OrderedDict()
 295         self.StructName = None
 296         self.PcdDefineLineNo = 0
 297         self.PkgPath = ""
 298         self.DefaultValueFromDec = ""
 299         self.DefaultValueFromDecInfo = None
 300         self.ValueChain = set()
 301         self.PcdFieldValueFromComm = OrderedDict()
 302         self.PcdFieldValueFromFdf = OrderedDict()
 303         self.DefaultFromDSC=None
 304         self.PcdFiledValueFromDscComponent = OrderedDict()
 305     def __repr__(self):
 306         return self.TypeName
 307
 308     def AddDefaultValue (self, FieldName, Value, FileName="", LineNo=0,DimensionAttr ="-1"):
 309         if DimensionAttr not in self.DefaultValues:
 310             self.DefaultValues[DimensionAttr] = collections.OrderedDict()
 311         if FieldName in self.DefaultValues[DimensionAttr]:
 312             del self.DefaultValues[DimensionAttr][FieldName]
 313         self.DefaultValues[DimensionAttr][FieldName] = [Value.strip(), FileName, LineNo]
 314         return self.DefaultValues[DimensionAttr][FieldName]
 315
 316     def SetDecDefaultValue(self, DefaultValue,decpath=None,lineno=None):
 317         self.DefaultValueFromDec = DefaultValue
 318         self.DefaultValueFromDecInfo = (decpath,lineno)
 319     def AddOverrideValue (self, FieldName, Value, SkuName, DefaultStoreName, FileName="", LineNo=0, DimensionAttr = '-1'):
 320         if SkuName not in self.SkuOverrideValues:
 321             self.SkuOverrideValues[SkuName] = OrderedDict()
 322         if DefaultStoreName not in self.SkuOverrideValues[SkuName]:
 323             self.SkuOverrideValues[SkuName][DefaultStoreName] = OrderedDict()
 324         if DimensionAttr not in self.SkuOverrideValues[SkuName][DefaultStoreName]:
 325             self.SkuOverrideValues[SkuName][DefaultStoreName][DimensionAttr] = collections.OrderedDict()
 326         if FieldName in self.SkuOverrideValues[SkuName][DefaultStoreName][DimensionAttr]:
 327             del self.SkuOverrideValues[SkuName][DefaultStoreName][DimensionAttr][FieldName]
 328         self.SkuOverrideValues[SkuName][DefaultStoreName][DimensionAttr][FieldName] = [Value.strip(), FileName, LineNo]
 329         return self.SkuOverrideValues[SkuName][DefaultStoreName][DimensionAttr][FieldName]
 330
 331     def AddComponentOverrideValue(self,FieldName, Value, ModuleGuid, FileName="", LineNo=0, DimensionAttr = '-1'):
 332         self.PcdFiledValueFromDscComponent.setdefault(ModuleGuid, OrderedDict())
 333         self.PcdFiledValueFromDscComponent[ModuleGuid].setdefault(DimensionAttr,OrderedDict())
 334         self.PcdFiledValueFromDscComponent[ModuleGuid][DimensionAttr][FieldName] =  [Value.strip(), FileName, LineNo]
 335         return self.PcdFiledValueFromDscComponent[ModuleGuid][DimensionAttr][FieldName]
 336
 337     def SetPcdMode (self, PcdMode):
 338         self.PcdMode = PcdMode
 339
 340     def copy(self, PcdObject):
 341         self.TokenCName = PcdObject.TokenCName if PcdObject.TokenCName else self.TokenCName
 342         self.TokenSpaceGuidCName = PcdObject.TokenSpaceGuidCName if PcdObject.TokenSpaceGuidCName else PcdObject.TokenSpaceGuidCName
 343         self.TokenSpaceGuidValue = PcdObject.TokenSpaceGuidValue if PcdObject.TokenSpaceGuidValue else self.TokenSpaceGuidValue
 344         self.Type = PcdObject.Type if PcdObject.Type else self.Type
 345         self._DatumType = PcdObject.DatumType if PcdObject.DatumType else self.DatumType
 346         self.DefaultValue = PcdObject.DefaultValue if  PcdObject.DefaultValue else self.DefaultValue
 347         self.TokenValue = PcdObject.TokenValue if PcdObject.TokenValue else self.TokenValue
 348         self.MaxDatumSize = PcdObject.MaxDatumSize if PcdObject.MaxDatumSize else self.MaxDatumSize
 349         self.SkuInfoList = PcdObject.SkuInfoList if PcdObject.SkuInfoList else self.SkuInfoList
 350         self.Phase = PcdObject.Phase if PcdObject.Phase else self.Phase
 351         self.Pending = PcdObject.Pending if PcdObject.Pending else self.Pending
 352         self.IsOverrided = PcdObject.IsOverrided if PcdObject.IsOverrided else self.IsOverrided
 353         self.IsFromBinaryInf = PcdObject.IsFromBinaryInf if PcdObject.IsFromBinaryInf else self.IsFromBinaryInf
 354         self.IsFromDsc = PcdObject.IsFromDsc if PcdObject.IsFromDsc else self.IsFromDsc
 355         self.validateranges = PcdObject.validateranges if PcdObject.validateranges else self.validateranges
 356         self.validlists = PcdObject.validlists if PcdObject.validlists else self.validlists
 357         self.expressions = PcdObject.expressions if PcdObject.expressions else self.expressions
 358         self.DscRawValue = PcdObject.DscRawValue if PcdObject.DscRawValue else self.DscRawValue
 359         self.DscRawValueInfo = PcdObject.DscRawValueInfo if PcdObject.DscRawValueInfo else self.DscRawValueInfo
 360         self.PcdValueFromComm = PcdObject.PcdValueFromComm if PcdObject.PcdValueFromComm else self.PcdValueFromComm
 361         self.PcdValueFromFdf = PcdObject.PcdValueFromFdf if PcdObject.PcdValueFromFdf else self.PcdValueFromFdf
 362         self.CustomAttribute = PcdObject.CustomAttribute if PcdObject.CustomAttribute else self.CustomAttribute
 363         self.UserDefinedDefaultStoresFlag = PcdObject.UserDefinedDefaultStoresFlag if PcdObject.UserDefinedDefaultStoresFlag else self.UserDefinedDefaultStoresFlag
 364         if isinstance(PcdObject, StructurePcd):
 365             self.StructuredPcdIncludeFile = PcdObject.StructuredPcdIncludeFile if PcdObject.StructuredPcdIncludeFile else self.StructuredPcdIncludeFile
 366             self.PackageDecs = PcdObject.PackageDecs if PcdObject.PackageDecs else self.PackageDecs
 367             self.DefaultValues = PcdObject.DefaultValues if PcdObject.DefaultValues else self.DefaultValues
 368             self.PcdMode = PcdObject.PcdMode if PcdObject.PcdMode else self.PcdMode
 369             self.DefaultValueFromDec = PcdObject.DefaultValueFromDec if PcdObject.DefaultValueFromDec else self.DefaultValueFromDec
 370             self.DefaultValueFromDecInfo = PcdObject.DefaultValueFromDecInfo if PcdObject.DefaultValueFromDecInfo else self.DefaultValueFromDecInfo
 371             self.SkuOverrideValues = PcdObject.SkuOverrideValues if PcdObject.SkuOverrideValues else self.SkuOverrideValues
 372             self.StructName = PcdObject.DatumType if PcdObject.DatumType else self.StructName
 373             self.PcdDefineLineNo = PcdObject.PcdDefineLineNo if PcdObject.PcdDefineLineNo else self.PcdDefineLineNo
 374             self.PkgPath = PcdObject.PkgPath if PcdObject.PkgPath else self.PkgPath
 375             self.ValueChain = PcdObject.ValueChain if PcdObject.ValueChain else self.ValueChain
 376             self.PcdFieldValueFromComm = PcdObject.PcdFieldValueFromComm if PcdObject.PcdFieldValueFromComm else self.PcdFieldValueFromComm
 377             self.PcdFieldValueFromFdf = PcdObject.PcdFieldValueFromFdf if PcdObject.PcdFieldValueFromFdf else self.PcdFieldValueFromFdf
 378             self.PcdFiledValueFromDscComponent = PcdObject.PcdFiledValueFromDscComponent if PcdObject.PcdFiledValueFromDscComponent else self.PcdFiledValueFromDscComponent
 379
 380     def __deepcopy__(self,memo):
 381         new_pcd = StructurePcd()
 382         self.sharedcopy(new_pcd)
 383
 384         new_pcd.DefaultValueFromDec = self.DefaultValueFromDec
 385         new_pcd.DefaultValueFromDecInfo = self.DefaultValueFromDecInfo
 386         new_pcd.PcdMode = self.PcdMode
 387         new_pcd.StructName = self.DatumType
 388         new_pcd.PcdDefineLineNo = self.PcdDefineLineNo
 389         new_pcd.PkgPath = self.PkgPath
 390         new_pcd.StructuredPcdIncludeFile = [item for item in self.StructuredPcdIncludeFile]
 391         new_pcd.PackageDecs = [item for item in self.PackageDecs]
 392         new_pcd.DefaultValues = CopyDict(self.DefaultValues)
 393         new_pcd.DefaultFromDSC=CopyDict(self.DefaultFromDSC)
 394         new_pcd.SkuOverrideValues = CopyDict(self.SkuOverrideValues)
 395         new_pcd.PcdFieldValueFromComm = CopyDict(self.PcdFieldValueFromComm)
 396         new_pcd.PcdFieldValueFromFdf = CopyDict(self.PcdFieldValueFromFdf)
 397         new_pcd.PcdFiledValueFromDscComponent = CopyDict(self.PcdFiledValueFromDscComponent)
 398         new_pcd.ValueChain = {item for item in self.ValueChain}
 399         return new_pcd
 400
 401 LibraryClassObject = namedtuple('LibraryClassObject', ['LibraryClass','SupModList'])
 402
 403 class BuildData(object):
 404     # dict used to convert PCD type in database to string used by build tool
 405
 406     _PCD_TYPE_STRING_ = {
 407         MODEL_PCD_FIXED_AT_BUILD        :   TAB_PCDS_FIXED_AT_BUILD,
 408         MODEL_PCD_PATCHABLE_IN_MODULE   :   TAB_PCDS_PATCHABLE_IN_MODULE,
 409         MODEL_PCD_FEATURE_FLAG          :   TAB_PCDS_FEATURE_FLAG,
 410         MODEL_PCD_DYNAMIC               :   TAB_PCDS_DYNAMIC,
 411         MODEL_PCD_DYNAMIC_DEFAULT       :   TAB_PCDS_DYNAMIC,
 412         MODEL_PCD_DYNAMIC_HII           :   TAB_PCDS_DYNAMIC_HII,
 413         MODEL_PCD_DYNAMIC_VPD           :   TAB_PCDS_DYNAMIC_VPD,
 414         MODEL_PCD_DYNAMIC_EX            :   TAB_PCDS_DYNAMIC_EX,
 415         MODEL_PCD_DYNAMIC_EX_DEFAULT    :   TAB_PCDS_DYNAMIC_EX,
 416         MODEL_PCD_DYNAMIC_EX_HII        :   TAB_PCDS_DYNAMIC_EX_HII,
 417         MODEL_PCD_DYNAMIC_EX_VPD        :   TAB_PCDS_DYNAMIC_EX_VPD,
 418     }
 419
 420     def UpdatePcdTypeDict(self):
 421         if GlobalData.gCommandLineDefines.get(TAB_DSC_DEFINES_PCD_DYNAMIC_AS_DYNAMICEX,"FALSE").upper() == "TRUE":
 422             self._PCD_TYPE_STRING_ = {
 423                 MODEL_PCD_FIXED_AT_BUILD        :   TAB_PCDS_FIXED_AT_BUILD,
 424                 MODEL_PCD_PATCHABLE_IN_MODULE   :   TAB_PCDS_PATCHABLE_IN_MODULE,
 425                 MODEL_PCD_FEATURE_FLAG          :   TAB_PCDS_FEATURE_FLAG,
 426                 MODEL_PCD_DYNAMIC               :   TAB_PCDS_DYNAMIC_EX,
 427                 MODEL_PCD_DYNAMIC_DEFAULT       :   TAB_PCDS_DYNAMIC_EX,
 428                 MODEL_PCD_DYNAMIC_HII           :   TAB_PCDS_DYNAMIC_EX_HII,
 429                 MODEL_PCD_DYNAMIC_VPD           :   TAB_PCDS_DYNAMIC_EX_VPD,
 430                 MODEL_PCD_DYNAMIC_EX            :   TAB_PCDS_DYNAMIC_EX,
 431                 MODEL_PCD_DYNAMIC_EX_DEFAULT    :   TAB_PCDS_DYNAMIC_EX,
 432                 MODEL_PCD_DYNAMIC_EX_HII        :   TAB_PCDS_DYNAMIC_EX_HII,
 433                 MODEL_PCD_DYNAMIC_EX_VPD        :   TAB_PCDS_DYNAMIC_EX_VPD,
 434             }
 435
 436     ## Convert the class to a string
 437     #
 438     #  Convert member MetaFile of the class to a string
 439     #
 440     #  @retval string Formatted String
 441     #
 442     def __str__(self):
 443         return str(self.MetaFile)
 444
 445     ## Override __eq__ function
 446     #
 447     # Check whether ModuleBuildClassObjects are the same
 448     #
 449     # @retval False The two ModuleBuildClassObjects are different
 450     # @retval True  The two ModuleBuildClassObjects are the same
 451     #
 452     def __eq__(self, Other):
 453         return self.MetaFile == Other
 454
 455     ## Override __hash__ function
 456     #
 457     # Use MetaFile as key in hash table
 458     #
 459     # @retval string Key for hash table
 460     #
 461     def __hash__(self):
 462         return hash(self.MetaFile)
 463
 464 ## ModuleBuildClassObject
 465 #
 466 # This Class defines ModuleBuildClass
 467 #
 468 # @param object:               Inherited from object class
 469 #
 470 # @var MetaFile:              To store value for module meta file path
 471 # @var BaseName:               To store value for BaseName
 472 # @var ModuleType:             To store value for ModuleType
 473 # @var Guid:                   To store value for Guid
 474 # @var Version:                To store value for Version
 475 # @var PcdIsDriver:            To store value for PcdIsDriver
 476 # @var BinaryModule:           To store value for BinaryModule
 477 # @var CustomMakefile:         To store value for CustomMakefile
 478 # @var Specification:          To store value for Specification
 479 # @var Shadow                  To store value for Shadow
 480 # @var LibraryClass:           To store value for LibraryClass, it is a list structure as
 481 #                              [ LibraryClassObject, ...]
 482 # @var ModuleEntryPointList:   To store value for ModuleEntryPointList
 483 # @var ModuleUnloadImageList:  To store value for ModuleUnloadImageList
 484 # @var ConstructorList:        To store value for ConstructorList
 485 # @var DestructorList:         To store value for DestructorList
 486 # @var Binaries:               To store value for Binaries, it is a list structure as
 487 #                              [ ModuleBinaryClassObject, ...]
 488 # @var Sources:                To store value for Sources, it is a list structure as
 489 #                              [ ModuleSourceFilesClassObject, ... ]
 490 # @var LibraryClasses:         To store value for LibraryClasses, it is a set structure as
 491 #                              { [LibraryClassName, ModuleType] : LibraryClassInfFile }
 492 # @var Protocols:              To store value for Protocols, it is a list structure as
 493 #                              [ ProtocolName, ... ]
 494 # @var Ppis:                   To store value for Ppis, it is a list structure as
 495 #                              [ PpiName, ... ]
 496 # @var Guids:                  To store value for Guids, it is a list structure as
 497 #                              [ GuidName, ... ]
 498 # @var Includes:               To store value for Includes, it is a list structure as
 499 #                              [ IncludePath, ... ]
 500 # @var Packages:               To store value for Packages, it is a list structure as
 501 #                              [ DecFileName, ... ]
 502 # @var Pcds:                   To store value for Pcds, it is a set structure as
 503 #                              { [(PcdCName, PcdGuidCName)] : PcdClassObject}
 504 # @var BuildOptions:           To store value for BuildOptions, it is a set structure as
 505 #                              { [BuildOptionKey] : BuildOptionValue}
 506 # @var Depex:                  To store value for Depex
 507 #
 508 class ModuleBuildClassObject(BuildData):
 509     def __init__(self):
 510         self.AutoGenVersion          = 0
 511         self.MetaFile                = ''
 512         self.BaseName                = ''
 513         self.ModuleType              = ''
 514         self.Guid                    = ''
 515         self.Version                 = ''
 516         self.PcdIsDriver             = ''
 517         self.BinaryModule            = ''
 518         self.Shadow                  = ''
 519         self.CustomMakefile          = {}
 520         self.Specification           = {}
 521         self.LibraryClass            = []
 522         self.ModuleEntryPointList    = []
 523         self.ModuleUnloadImageList   = []
 524         self.ConstructorList         = []
 525         self.DestructorList          = []
 526
 527         self.Binaries                = []
 528         self.Sources                 = []
 529         self.LibraryClasses          = OrderedDict()
 530         self.Libraries               = []
 531         self.Protocols               = []
 532         self.Ppis                    = []
 533         self.Guids                   = []
 534         self.Includes                = []
 535         self.Packages                = []
 536         self.Pcds                    = {}
 537         self.BuildOptions            = {}
 538         self.Depex                   = {}
 539         self.StrPcdSet               = []
 540         self.StrPcdOverallValue      = {}
 541
 542 ## PackageBuildClassObject
 543 #
 544 # This Class defines PackageBuildClass
 545 #
 546 # @param object:        Inherited from object class
 547 #
 548 # @var MetaFile:       To store value for package meta file path
 549 # @var PackageName:     To store value for PackageName
 550 # @var Guid:            To store value for Guid
 551 # @var Version:         To store value for Version
 552 # @var Protocols:       To store value for Protocols, it is a set structure as
 553 #                       { [ProtocolName] : Protocol Guid, ... }
 554 # @var Ppis:            To store value for Ppis, it is a set structure as
 555 #                       { [PpiName] : Ppi Guid, ... }
 556 # @var Guids:           To store value for Guids, it is a set structure as
 557 #                       { [GuidName] : Guid, ... }
 558 # @var Includes:        To store value for Includes, it is a list structure as
 559 #                       [ IncludePath, ... ]
 560 # @var LibraryClasses:  To store value for LibraryClasses, it is a set structure as
 561 #                       { [LibraryClassName] : LibraryClassInfFile }
 562 # @var Pcds:            To store value for Pcds, it is a set structure as
 563 #                       { [(PcdCName, PcdGuidCName)] : PcdClassObject}
 564 #
 565 class PackageBuildClassObject(BuildData):
 566     def __init__(self):
 567         self.MetaFile                = ''
 568         self.PackageName             = ''
 569         self.Guid                    = ''
 570         self.Version                 = ''
 571
 572         self.Protocols               = {}
 573         self.Ppis                    = {}
 574         self.Guids                   = {}
 575         self.Includes                = []
 576         self.LibraryClasses          = {}
 577         self.Pcds                    = {}
 578
 579 ## PlatformBuildClassObject
 580 #
 581 # This Class defines PlatformBuildClass
 582 #
 583 # @param object:          Inherited from object class
 584 #
 585 # @var MetaFile:         To store value for platform meta-file path
 586 # @var PlatformName:      To store value for PlatformName
 587 # @var Guid:              To store value for Guid
 588 # @var Version:           To store value for Version
 589 # @var DscSpecification:  To store value for DscSpecification
 590 # @var OutputDirectory:   To store value for OutputDirectory
 591 # @var FlashDefinition:   To store value for FlashDefinition
 592 # @var BuildNumber:       To store value for BuildNumber
 593 # @var SkuIds:            To store value for SkuIds, it is a set structure as
 594 #                         { 'SkuName' : SkuId, '!include' : includefilename, ...}
 595 # @var Modules:           To store value for Modules, it is a list structure as
 596 #                         [ InfFileName, ... ]
 597 # @var Libraries:         To store value for Libraries, it is a list structure as
 598 #                         [ InfFileName, ... ]
 599 # @var LibraryClasses:    To store value for LibraryClasses, it is a set structure as
 600 #                         { (LibraryClassName, ModuleType) : LibraryClassInfFile }
 601 # @var Pcds:              To store value for Pcds, it is a set structure as
 602 #                         { [(PcdCName, PcdGuidCName)] : PcdClassObject }
 603 # @var BuildOptions:      To store value for BuildOptions, it is a set structure as
 604 #                         { [BuildOptionKey] : BuildOptionValue }
 605 #
 606 class PlatformBuildClassObject(BuildData):
 607     def __init__(self):
 608         self.MetaFile                = ''
 609         self.PlatformName            = ''
 610         self.Guid                    = ''
 611         self.Version                 = ''
 612         self.DscSpecification        = ''
 613         self.OutputDirectory         = ''
 614         self.FlashDefinition         = ''
 615         self.BuildNumber             = ''
 616
 617         self.SkuIds                  = {}
 618         self.Modules                 = []
 619         self.LibraryInstances        = []
 620         self.LibraryClasses          = {}
 621         self.Libraries               = {}
 622         self.Pcds                    = {}
 623         self.BuildOptions            = {}