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