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