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