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 # This program and the accompanying materials
   6 # are licensed and made available under the terms and conditions of the BSD License
   7 # which accompanies this distribution.  The full text of the license may be found at
   8 # http://opensource.org/licenses/bsd-license.php
   9 #
  10 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12 #
  13
  14 from collections import OrderedDict, namedtuple
  15 from Common.DataType import *
  16 import collections
  17 import re
  18 from collections import OrderedDict
  19 StructPattern = re.compile(r'[_a-zA-Z][0-9A-Za-z_\[\]]*$')
  20 ArrayIndex = re.compile("\[\s*\d{0,1}\s*\]")
  21 ## PcdClassObject
  22 #
  23 # This Class is used for PcdObject
  24 #
  25 # @param object:             Inherited from object class
  26 # @param Name:               Input value for Name of Pcd, default is None
  27 # @param Guid:               Input value for Guid of Pcd, default is None
  28 # @param Type:               Input value for Type of Pcd, default is None
  29 # @param DatumType:          Input value for DatumType of Pcd, default is None
  30 # @param Value:              Input value for Value of Pcd, default is None
  31 # @param Token:              Input value for Token of Pcd, default is None
  32 # @param MaxDatumSize:       Input value for MaxDatumSize of Pcd, default is None
  33 # @param SkuInfoList:        Input value for SkuInfoList of Pcd, default is {}
  34 # @param IsOverrided:        Input value for IsOverrided of Pcd, default is False
  35 # @param GuidValue:          Input value for TokenSpaceGuidValue of Pcd, default is None
  36 #
  37 # @var TokenCName:           To store value for TokenCName
  38 # @var TokenSpaceGuidCName:  To store value for TokenSpaceGuidCName
  39 # @var Type:                 To store value for Type
  40 # @var DatumType:            To store value for DatumType
  41 # @var TokenValue:           To store value for TokenValue
  42 # @var MaxDatumSize:         To store value for MaxDatumSize
  43 # @var SkuInfoList:          To store value for SkuInfoList
  44 # @var IsOverrided:          To store value for IsOverrided
  45 # @var Phase:                To store value for Phase, default is "DXE"
  46 #
  47 class PcdClassObject(object):
  48     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):
  49         self.TokenCName = Name
  50         self.TokenSpaceGuidCName = Guid
  51         self.TokenSpaceGuidValue = GuidValue
  52         self.Type = Type
  53         self._DatumType = DatumType
  54         self.DefaultValue = Value
  55         self.TokenValue = Token
  56         self.MaxDatumSize = MaxDatumSize
  57         self.MaxSizeUserSet = None
  58         self.SkuInfoList = SkuInfoList if SkuInfoList is not None else OrderedDict()
  59         self.Phase = "DXE"
  60         self.Pending = False
  61         self.IsOverrided = IsOverrided
  62         self.IsFromBinaryInf = False
  63         self.IsFromDsc = False
  64         self.validateranges = validateranges if validateranges is not None else []
  65         self.validlists = validlists if validlists is not None else []
  66         self.expressions = expressions if expressions is not None else []
  67         self.DscDefaultValue = None
  68         self.DscRawValue = {}
  69         if IsDsc:
  70             self.DscDefaultValue = Value
  71         self.PcdValueFromComm = ""
  72         self.PcdValueFromFdf = ""
  73         self.CustomAttribute = {}
  74         self.UserDefinedDefaultStoresFlag = UserDefinedDefaultStoresFlag
  75         self._Capacity = None
  76
  77     @property
  78     def Capacity(self):
  79         self._Capacity = []
  80         dimension = ArrayIndex.findall(self._DatumType)
  81         for item in dimension:
  82             maxsize = item.lstrip("[").rstrip("]").strip()
  83             if not maxsize:
  84                 maxsize = "-1"
  85             self._Capacity.append(maxsize)
  86         if hasattr(self, "SkuOverrideValues"):
  87             for sku in self.SkuOverrideValues:
  88                 for defaultstore in self.SkuOverrideValues[sku]:
  89                     fields = self.SkuOverrideValues[sku][defaultstore]
  90                     for demesionattr in fields:
  91                         deme = ArrayIndex.findall(demesionattr)
  92                         for i in range(len(deme)-1):
  93                             if int(deme[i].lstrip("[").rstrip("]").strip()) > int(self._Capacity[i]):
  94                                 print "error"
  95         if hasattr(self,"DefaultValues"):
  96             for demesionattr in self.DefaultValues:
  97                 deme = ArrayIndex.findall(demesionattr)
  98                 for i in range(len(deme)-1):
  99                     if int(deme[i].lstrip("[").rstrip("]").strip()) > int(self._Capacity[i]):
 100                         print "error"
 101         self._Capacity = [str(int(d) + 1) for d in self._Capacity]
 102         return self._Capacity
 103     @property
 104     def DatumType(self):
 105         return self._DatumType
 106
 107     @DatumType.setter
 108     def DatumType(self,DataType):
 109         self._DatumType = DataType
 110         self._Capacity = None
 111
 112     @property
 113     def BaseDatumType(self):
 114         if self.IsArray():
 115             return self._DatumType[:self._DatumType.index("[")]
 116         else:
 117             return self._DatumType
 118     def IsArray(self):
 119         return True if len(self.Capacity) else False
 120
 121     def IsAggregateDatumType(self):
 122         if self.DatumType in [TAB_UINT8, TAB_UINT16, TAB_UINT32, TAB_UINT64, TAB_VOID, "BOOLEAN"]:
 123             return False
 124         if self.IsArray() or StructPattern.match(self.DatumType):
 125             return True
 126         return False
 127
 128     def IsSimpleTypeArray(self):
 129         if self.IsArray() and self.BaseDatumType in [TAB_UINT8, TAB_UINT16, TAB_UINT32, TAB_UINT64, "BOOLEAN"]:
 130             return True
 131         return False
 132
 133     @staticmethod
 134     def GetPcdMaxSizeWorker(PcdString, MaxSize):
 135         if PcdString.startswith("{") and PcdString.endswith("}"):
 136             return  max([len(PcdString.split(",")),MaxSize])
 137
 138         if PcdString.startswith("\"") or PcdString.startswith("\'"):
 139             return  max([len(PcdString)-2+1,MaxSize])
 140
 141         if PcdString.startswith("L\""):
 142             return  max([2*(len(PcdString)-3+1),MaxSize])
 143
 144         return max([len(PcdString),MaxSize])
 145
 146     ## Get the maximum number of bytes
 147     def GetPcdMaxSize(self):
 148         if self.DatumType in TAB_PCD_NUMERIC_TYPES:
 149             return MAX_SIZE_TYPE[self.DatumType]
 150
 151         MaxSize = int(self.MaxDatumSize, 10) if self.MaxDatumSize else 0
 152         if self.PcdValueFromFdf:
 153             MaxSize = self.GetPcdMaxSizeWorker(self.PcdValueFromFdf,MaxSize)
 154         if self.PcdValueFromComm:
 155             MaxSize = self.GetPcdMaxSizeWorker(self.PcdValueFromComm,MaxSize)
 156         if hasattr(self, "DefaultValueFromDec"):
 157             MaxSize = self.GetPcdMaxSizeWorker(self.DefaultValueFromDec,MaxSize)
 158         return MaxSize
 159
 160     ## Get the number of bytes
 161     def GetPcdSize(self):
 162         if self.DatumType in TAB_PCD_NUMERIC_TYPES:
 163             return MAX_SIZE_TYPE[self.DatumType]
 164         if not self.DefaultValue:
 165             return 1
 166         elif self.DefaultValue[0] == 'L':
 167             return (len(self.DefaultValue) - 2) * 2
 168         elif self.DefaultValue[0] == '{':
 169             return len(self.DefaultValue.split(','))
 170         else:
 171             return len(self.DefaultValue) - 1
 172
 173
 174     ## Convert the class to a string
 175     #
 176     #  Convert each member of the class to string
 177     #  Organize to a signle line format string
 178     #
 179     #  @retval Rtn Formatted String
 180     #
 181     def __str__(self):
 182         Rtn = '\tTokenCName=' + str(self.TokenCName) + ', ' + \
 183               'TokenSpaceGuidCName=' + str(self.TokenSpaceGuidCName) + ', ' + \
 184               'Type=' + str(self.Type) + ', ' + \
 185               'DatumType=' + str(self.DatumType) + ', ' + \
 186               'DefaultValue=' + str(self.DefaultValue) + ', ' + \
 187               'TokenValue=' + str(self.TokenValue) + ', ' + \
 188               'MaxDatumSize=' + str(self.MaxDatumSize) + ', '
 189         for Item in self.SkuInfoList.values():
 190             Rtn = Rtn + 'SkuId=' + Item.SkuId + ', ' + 'SkuIdName=' + Item.SkuIdName
 191         Rtn = Rtn + ', IsOverrided=' + str(self.IsOverrided)
 192
 193         return Rtn
 194
 195     ## Override __eq__ function
 196     #
 197     # Check whether pcds are the same
 198     #
 199     # @retval False The two pcds are different
 200     # @retval True  The two pcds are the same
 201     #
 202     def __eq__(self, Other):
 203         return Other and self.TokenCName == Other.TokenCName and self.TokenSpaceGuidCName == Other.TokenSpaceGuidCName
 204
 205     ## Override __hash__ function
 206     #
 207     # Use (TokenCName, TokenSpaceGuidCName) as key in hash table
 208     #
 209     # @retval truple() Key for hash table
 210     #
 211     def __hash__(self):
 212         return hash((self.TokenCName, self.TokenSpaceGuidCName))
 213
 214 class StructurePcd(PcdClassObject):
 215     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):
 216         if SkuInfoList is None:
 217             SkuInfoList = {}
 218         if validateranges is None:
 219             validateranges = []
 220         if validlists is None:
 221             validlists = []
 222         if expressions is None:
 223             expressions = []
 224         if Packages is None:
 225             Packages = []
 226         super(StructurePcd, self).__init__(Name, Guid, Type, DatumType, Value, Token, MaxDatumSize, SkuInfoList, IsOverrided, GuidValue, validateranges, validlists, expressions)
 227         self.StructuredPcdIncludeFile = [] if StructuredPcdIncludeFile is None else StructuredPcdIncludeFile
 228         self.PackageDecs = Packages
 229         self.DefaultStoreName = [default_store]
 230         self.DefaultValues = OrderedDict()
 231         self.PcdMode = None
 232         self.SkuOverrideValues = OrderedDict()
 233         self.StructName = None
 234         self.PcdDefineLineNo = 0
 235         self.PkgPath = ""
 236         self.DefaultValueFromDec = ""
 237         self.ValueChain = set()
 238         self.PcdFieldValueFromComm = OrderedDict()
 239         self.PcdFieldValueFromFdf = OrderedDict()
 240     def __repr__(self):
 241         return self.TypeName
 242
 243     def AddDefaultValue (self, FieldName, Value, FileName="", LineNo=0,DimensionAttr ="-1"):
 244         if DimensionAttr not in self.DefaultValues:
 245             self.DefaultValues[DimensionAttr] = collections.OrderedDict()
 246         if FieldName in self.DefaultValues[DimensionAttr]:
 247             del self.DefaultValues[DimensionAttr][FieldName]
 248         self.DefaultValues[DimensionAttr][FieldName] = [Value.strip(), FileName, LineNo]
 249         return self.DefaultValues[DimensionAttr][FieldName]
 250
 251     def SetDecDefaultValue(self, DefaultValue):
 252         self.DefaultValueFromDec = DefaultValue
 253     def AddOverrideValue (self, FieldName, Value, SkuName, DefaultStoreName, FileName="", LineNo=0, DimensionAttr = '-1'):
 254         if SkuName not in self.SkuOverrideValues:
 255             self.SkuOverrideValues[SkuName] = OrderedDict()
 256         if DefaultStoreName not in self.SkuOverrideValues[SkuName]:
 257             self.SkuOverrideValues[SkuName][DefaultStoreName] = OrderedDict()
 258         if DimensionAttr not in self.SkuOverrideValues[SkuName][DefaultStoreName]:
 259             self.SkuOverrideValues[SkuName][DefaultStoreName][DimensionAttr] = collections.OrderedDict()
 260         if FieldName in self.SkuOverrideValues[SkuName][DefaultStoreName][DimensionAttr]:
 261             del self.SkuOverrideValues[SkuName][DefaultStoreName][FieldName][DimensionAttr]
 262         self.SkuOverrideValues[SkuName][DefaultStoreName][DimensionAttr][FieldName] = [Value.strip(), FileName, LineNo]
 263         return self.SkuOverrideValues[SkuName][DefaultStoreName][DimensionAttr][FieldName]
 264
 265     def SetPcdMode (self, PcdMode):
 266         self.PcdMode = PcdMode
 267
 268     def copy(self, PcdObject):
 269         self.TokenCName = PcdObject.TokenCName if PcdObject.TokenCName else self.TokenCName
 270         self.TokenSpaceGuidCName = PcdObject.TokenSpaceGuidCName if PcdObject.TokenSpaceGuidCName else PcdObject.TokenSpaceGuidCName
 271         self.TokenSpaceGuidValue = PcdObject.TokenSpaceGuidValue if PcdObject.TokenSpaceGuidValue else self.TokenSpaceGuidValue
 272         self.Type = PcdObject.Type if PcdObject.Type else self.Type
 273         self._DatumType = PcdObject.DatumType if PcdObject.DatumType else self.DatumType
 274         self.DefaultValue = PcdObject.DefaultValue if  PcdObject.DefaultValue else self.DefaultValue
 275         self.TokenValue = PcdObject.TokenValue if PcdObject.TokenValue else self.TokenValue
 276         self.MaxDatumSize = PcdObject.MaxDatumSize if PcdObject.MaxDatumSize else self.MaxDatumSize
 277         self.SkuInfoList = PcdObject.SkuInfoList if PcdObject.SkuInfoList else self.SkuInfoList
 278         self.Phase = PcdObject.Phase if PcdObject.Phase else self.Phase
 279         self.Pending = PcdObject.Pending if PcdObject.Pending else self.Pending
 280         self.IsOverrided = PcdObject.IsOverrided if PcdObject.IsOverrided else self.IsOverrided
 281         self.IsFromBinaryInf = PcdObject.IsFromBinaryInf if PcdObject.IsFromBinaryInf else self.IsFromBinaryInf
 282         self.IsFromDsc = PcdObject.IsFromDsc if PcdObject.IsFromDsc else self.IsFromDsc
 283         self.validateranges = PcdObject.validateranges if PcdObject.validateranges else self.validateranges
 284         self.validlists = PcdObject.validlists if PcdObject.validlists else self.validlists
 285         self.expressions = PcdObject.expressions if PcdObject.expressions else self.expressions
 286         self.DscRawValue = PcdObject.DscRawValue if PcdObject.DscRawValue else self.DscRawValue
 287         self.PcdValueFromComm = PcdObject.PcdValueFromComm if PcdObject.PcdValueFromComm else self.PcdValueFromComm
 288         self.PcdValueFromFdf = PcdObject.PcdValueFromFdf if PcdObject.PcdValueFromFdf else self.PcdValueFromFdf
 289         self.CustomAttribute = PcdObject.CustomAttribute if PcdObject.CustomAttribute else self.CustomAttribute
 290         self.UserDefinedDefaultStoresFlag = PcdObject.UserDefinedDefaultStoresFlag if PcdObject.UserDefinedDefaultStoresFlag else self.UserDefinedDefaultStoresFlag
 291         if isinstance(PcdObject, StructurePcd):
 292             self.StructuredPcdIncludeFile = PcdObject.StructuredPcdIncludeFile if PcdObject.StructuredPcdIncludeFile else self.StructuredPcdIncludeFile
 293             self.PackageDecs = PcdObject.PackageDecs if PcdObject.PackageDecs else self.PackageDecs
 294             self.DefaultValues = PcdObject.DefaultValues if PcdObject.DefaultValues else self.DefaultValues
 295             self.PcdMode = PcdObject.PcdMode if PcdObject.PcdMode else self.PcdMode
 296             self.DefaultFromDSC=None
 297             self.DefaultValueFromDec = PcdObject.DefaultValueFromDec if PcdObject.DefaultValueFromDec else self.DefaultValueFromDec
 298             self.SkuOverrideValues = PcdObject.SkuOverrideValues if PcdObject.SkuOverrideValues else self.SkuOverrideValues
 299             self.StructName = PcdObject.DatumType if PcdObject.DatumType else self.StructName
 300             self.PcdDefineLineNo = PcdObject.PcdDefineLineNo if PcdObject.PcdDefineLineNo else self.PcdDefineLineNo
 301             self.PkgPath = PcdObject.PkgPath if PcdObject.PkgPath else self.PkgPath
 302             self.ValueChain = PcdObject.ValueChain if PcdObject.ValueChain else self.ValueChain
 303             self.PcdFieldValueFromComm = PcdObject.PcdFieldValueFromComm if PcdObject.PcdFieldValueFromComm else self.PcdFieldValueFromComm
 304             self.PcdFieldValueFromFdf = PcdObject.PcdFieldValueFromFdf if PcdObject.PcdFieldValueFromFdf else self.PcdFieldValueFromFdf
 305
 306 LibraryClassObject = namedtuple('LibraryClassObject', ['LibraryClass','SupModList'], verbose=False)
 307
 308 ## ModuleBuildClassObject
 309 #
 310 # This Class defines ModuleBuildClass
 311 #
 312 # @param object:               Inherited from object class
 313 #
 314 # @var MetaFile:              To store value for module meta file path
 315 # @var BaseName:               To store value for BaseName
 316 # @var ModuleType:             To store value for ModuleType
 317 # @var Guid:                   To store value for Guid
 318 # @var Version:                To store value for Version
 319 # @var PcdIsDriver:            To store value for PcdIsDriver
 320 # @var BinaryModule:           To store value for BinaryModule
 321 # @var CustomMakefile:         To store value for CustomMakefile
 322 # @var Specification:          To store value for Specification
 323 # @var Shadow                  To store value for Shadow
 324 # @var LibraryClass:           To store value for LibraryClass, it is a list structure as
 325 #                              [ LibraryClassObject, ...]
 326 # @var ModuleEntryPointList:   To store value for ModuleEntryPointList
 327 # @var ModuleUnloadImageList:  To store value for ModuleUnloadImageList
 328 # @var ConstructorList:        To store value for ConstructorList
 329 # @var DestructorList:         To store value for DestructorList
 330 # @var Binaries:               To store value for Binaries, it is a list structure as
 331 #                              [ ModuleBinaryClassObject, ...]
 332 # @var Sources:                To store value for Sources, it is a list structure as
 333 #                              [ ModuleSourceFilesClassObject, ... ]
 334 # @var LibraryClasses:         To store value for LibraryClasses, it is a set structure as
 335 #                              { [LibraryClassName, ModuleType] : LibraryClassInfFile }
 336 # @var Protocols:              To store value for Protocols, it is a list structure as
 337 #                              [ ProtocolName, ... ]
 338 # @var Ppis:                   To store value for Ppis, it is a list structure as
 339 #                              [ PpiName, ... ]
 340 # @var Guids:                  To store value for Guids, it is a list structure as
 341 #                              [ GuidName, ... ]
 342 # @var Includes:               To store value for Includes, it is a list structure as
 343 #                              [ IncludePath, ... ]
 344 # @var Packages:               To store value for Packages, it is a list structure as
 345 #                              [ DecFileName, ... ]
 346 # @var Pcds:                   To store value for Pcds, it is a set structure as
 347 #                              { [(PcdCName, PcdGuidCName)] : PcdClassObject}
 348 # @var BuildOptions:           To store value for BuildOptions, it is a set structure as
 349 #                              { [BuildOptionKey] : BuildOptionValue}
 350 # @var Depex:                  To store value for Depex
 351 #
 352 class ModuleBuildClassObject(object):
 353     def __init__(self):
 354         self.AutoGenVersion          = 0
 355         self.MetaFile                = ''
 356         self.BaseName                = ''
 357         self.ModuleType              = ''
 358         self.Guid                    = ''
 359         self.Version                 = ''
 360         self.PcdIsDriver             = ''
 361         self.BinaryModule            = ''
 362         self.Shadow                  = ''
 363         self.SourceOverridePath      = ''
 364         self.CustomMakefile          = {}
 365         self.Specification           = {}
 366         self.LibraryClass            = []
 367         self.ModuleEntryPointList    = []
 368         self.ModuleUnloadImageList   = []
 369         self.ConstructorList         = []
 370         self.DestructorList          = []
 371
 372         self.Binaries                = []
 373         self.Sources                 = []
 374         self.LibraryClasses          = OrderedDict()
 375         self.Libraries               = []
 376         self.Protocols               = []
 377         self.Ppis                    = []
 378         self.Guids                   = []
 379         self.Includes                = []
 380         self.Packages                = []
 381         self.Pcds                    = {}
 382         self.BuildOptions            = {}
 383         self.Depex                   = {}
 384
 385     ## Convert the class to a string
 386     #
 387     #  Convert member MetaFile of the class to a string
 388     #
 389     #  @retval string Formatted String
 390     #
 391     def __str__(self):
 392         return str(self.MetaFile)
 393
 394     ## Override __eq__ function
 395     #
 396     # Check whether ModuleBuildClassObjects are the same
 397     #
 398     # @retval False The two ModuleBuildClassObjects are different
 399     # @retval True  The two ModuleBuildClassObjects are the same
 400     #
 401     def __eq__(self, Other):
 402         return self.MetaFile == Other
 403
 404     ## Override __hash__ function
 405     #
 406     # Use MetaFile as key in hash table
 407     #
 408     # @retval string Key for hash table
 409     #
 410     def __hash__(self):
 411         return hash(self.MetaFile)
 412
 413 ## PackageBuildClassObject
 414 #
 415 # This Class defines PackageBuildClass
 416 #
 417 # @param object:        Inherited from object class
 418 #
 419 # @var MetaFile:       To store value for package meta file path
 420 # @var PackageName:     To store value for PackageName
 421 # @var Guid:            To store value for Guid
 422 # @var Version:         To store value for Version
 423 # @var Protocols:       To store value for Protocols, it is a set structure as
 424 #                       { [ProtocolName] : Protocol Guid, ... }
 425 # @var Ppis:            To store value for Ppis, it is a set structure as
 426 #                       { [PpiName] : Ppi Guid, ... }
 427 # @var Guids:           To store value for Guids, it is a set structure as
 428 #                       { [GuidName] : Guid, ... }
 429 # @var Includes:        To store value for Includes, it is a list structure as
 430 #                       [ IncludePath, ... ]
 431 # @var LibraryClasses:  To store value for LibraryClasses, it is a set structure as
 432 #                       { [LibraryClassName] : LibraryClassInfFile }
 433 # @var Pcds:            To store value for Pcds, it is a set structure as
 434 #                       { [(PcdCName, PcdGuidCName)] : PcdClassObject}
 435 #
 436 class PackageBuildClassObject(object):
 437     def __init__(self):
 438         self.MetaFile                = ''
 439         self.PackageName             = ''
 440         self.Guid                    = ''
 441         self.Version                 = ''
 442
 443         self.Protocols               = {}
 444         self.Ppis                    = {}
 445         self.Guids                   = {}
 446         self.Includes                = []
 447         self.LibraryClasses          = {}
 448         self.Pcds                    = {}
 449
 450     ## Convert the class to a string
 451     #
 452     #  Convert member MetaFile of the class to a string
 453     #
 454     #  @retval string Formatted String
 455     #
 456     def __str__(self):
 457         return str(self.MetaFile)
 458
 459     ## Override __eq__ function
 460     #
 461     # Check whether PackageBuildClassObjects are the same
 462     #
 463     # @retval False The two PackageBuildClassObjects are different
 464     # @retval True  The two PackageBuildClassObjects are the same
 465     #
 466     def __eq__(self, Other):
 467         return self.MetaFile == Other
 468
 469     ## Override __hash__ function
 470     #
 471     # Use MetaFile as key in hash table
 472     #
 473     # @retval string Key for hash table
 474     #
 475     def __hash__(self):
 476         return hash(self.MetaFile)
 477
 478 ## PlatformBuildClassObject
 479 #
 480 # This Class defines PlatformBuildClass
 481 #
 482 # @param object:          Inherited from object class
 483 #
 484 # @var MetaFile:         To store value for platform meta-file path
 485 # @var PlatformName:      To store value for PlatformName
 486 # @var Guid:              To store value for Guid
 487 # @var Version:           To store value for Version
 488 # @var DscSpecification:  To store value for DscSpecification
 489 # @var OutputDirectory:   To store value for OutputDirectory
 490 # @var FlashDefinition:   To store value for FlashDefinition
 491 # @var BuildNumber:       To store value for BuildNumber
 492 # @var MakefileName:      To store value for MakefileName
 493 # @var SkuIds:            To store value for SkuIds, it is a set structure as
 494 #                         { 'SkuName' : SkuId, '!include' : includefilename, ...}
 495 # @var Modules:           To store value for Modules, it is a list structure as
 496 #                         [ InfFileName, ... ]
 497 # @var Libraries:         To store value for Libraries, it is a list structure as
 498 #                         [ InfFileName, ... ]
 499 # @var LibraryClasses:    To store value for LibraryClasses, it is a set structure as
 500 #                         { (LibraryClassName, ModuleType) : LibraryClassInfFile }
 501 # @var Pcds:              To store value for Pcds, it is a set structure as
 502 #                         { [(PcdCName, PcdGuidCName)] : PcdClassObject }
 503 # @var BuildOptions:      To store value for BuildOptions, it is a set structure as
 504 #                         { [BuildOptionKey] : BuildOptionValue }
 505 #
 506 class PlatformBuildClassObject(object):
 507     def __init__(self):
 508         self.MetaFile                = ''
 509         self.PlatformName            = ''
 510         self.Guid                    = ''
 511         self.Version                 = ''
 512         self.DscSpecification        = ''
 513         self.OutputDirectory         = ''
 514         self.FlashDefinition         = ''
 515         self.BuildNumber             = ''
 516         self.MakefileName            = ''
 517
 518         self.SkuIds                  = {}
 519         self.Modules                 = []
 520         self.LibraryInstances        = []
 521         self.LibraryClasses          = {}
 522         self.Libraries               = {}
 523         self.Pcds                    = {}
 524         self.BuildOptions            = {}
 525
 526     ## Convert the class to a string
 527     #
 528     #  Convert member MetaFile of the class to a string
 529     #
 530     #  @retval string Formatted String
 531     #
 532     def __str__(self):
 533         return str(self.MetaFile)
 534
 535     ## Override __eq__ function
 536     #
 537     # Check whether PlatformBuildClassObjects are the same
 538     #
 539     # @retval False The two PlatformBuildClassObjects are different
 540     # @retval True  The two PlatformBuildClassObjects are the same
 541     #
 542     def __eq__(self, Other):
 543         return self.MetaFile == Other
 544
 545     ## Override __hash__ function
 546     #
 547     # Use MetaFile as key in hash table
 548     #
 549     # @retval string Key for hash table
 550     #
 551     def __hash__(self):
 552         return hash(self.MetaFile)