## @file | |
# This file is used to define each component of the build database | |
# | |
# Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR> | |
# SPDX-License-Identifier: BSD-2-Clause-Patent | |
# | |
from collections import OrderedDict, namedtuple | |
from Common.DataType import * | |
import collections | |
import re | |
from collections import OrderedDict | |
from Common.Misc import CopyDict,ArrayIndex | |
import copy | |
from CommonDataClass.DataClass import * | |
import Common.EdkLogger as EdkLogger | |
import Common.GlobalData as GlobalData | |
from Common.BuildToolError import OPTION_VALUE_INVALID | |
from Common.caching import cached_property | |
StructPattern = re.compile(r'[_a-zA-Z][0-9A-Za-z_\[\]]*$') | |
## PcdClassObject | |
# | |
# This Class is used for PcdObject | |
# | |
# @param object: Inherited from object class | |
# @param Name: Input value for Name of Pcd, default is None | |
# @param Guid: Input value for Guid of Pcd, default is None | |
# @param Type: Input value for Type of Pcd, default is None | |
# @param DatumType: Input value for DatumType of Pcd, default is None | |
# @param Value: Input value for Value of Pcd, default is None | |
# @param Token: Input value for Token of Pcd, default is None | |
# @param MaxDatumSize: Input value for MaxDatumSize of Pcd, default is None | |
# @param SkuInfoList: Input value for SkuInfoList of Pcd, default is {} | |
# @param IsOverrided: Input value for IsOverrided of Pcd, default is False | |
# @param GuidValue: Input value for TokenSpaceGuidValue of Pcd, default is None | |
# | |
# @var TokenCName: To store value for TokenCName | |
# @var TokenSpaceGuidCName: To store value for TokenSpaceGuidCName | |
# @var Type: To store value for Type | |
# @var DatumType: To store value for DatumType | |
# @var TokenValue: To store value for TokenValue | |
# @var MaxDatumSize: To store value for MaxDatumSize | |
# @var SkuInfoList: To store value for SkuInfoList | |
# @var IsOverrided: To store value for IsOverrided | |
# @var Phase: To store value for Phase, default is "DXE" | |
# | |
class PcdClassObject(object): | |
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): | |
self.TokenCName = Name | |
self.TokenSpaceGuidCName = Guid | |
self.TokenSpaceGuidValue = GuidValue | |
self.Type = Type | |
self._DatumType = DatumType | |
self.DefaultValue = Value | |
self.TokenValue = Token | |
self.MaxDatumSize = MaxDatumSize | |
self.MaxSizeUserSet = None | |
self.SkuInfoList = SkuInfoList if SkuInfoList is not None else OrderedDict() | |
self.Phase = "DXE" | |
self.Pending = False | |
self.IsOverrided = IsOverrided | |
self.IsFromBinaryInf = False | |
self.IsFromDsc = False | |
self.validateranges = validateranges if validateranges is not None else [] | |
self.validlists = validlists if validlists is not None else [] | |
self.expressions = expressions if expressions is not None else [] | |
self.DscDefaultValue = None | |
self.DscRawValue = {} | |
self.DscRawValueInfo = {} | |
if IsDsc: | |
self.DscDefaultValue = Value | |
self.PcdValueFromComm = "" | |
self.PcdValueFromFdf = "" | |
self.PcdValueFromComponents = {} #{ModuleGuid:value, file_path,lineNo} | |
self.CustomAttribute = {} | |
self.UserDefinedDefaultStoresFlag = UserDefinedDefaultStoresFlag | |
self._Capacity = None | |
@property | |
def Capacity(self): | |
if self._Capacity is None: | |
self._Capacity = [] | |
dimension = ArrayIndex.findall(self._DatumType) | |
for item in dimension: | |
maxsize = item.lstrip("[").rstrip("]").strip() | |
if not maxsize: | |
maxsize = "-1" | |
maxsize = str(int(maxsize,16)) if maxsize.startswith(("0x","0X")) else maxsize | |
self._Capacity.append(maxsize) | |
if hasattr(self, "SkuOverrideValues"): | |
for sku in self.SkuOverrideValues: | |
for defaultstore in self.SkuOverrideValues[sku]: | |
fields = self.SkuOverrideValues[sku][defaultstore] | |
for demesionattr in fields: | |
fieldinfo = fields[demesionattr] | |
deme = ArrayIndex.findall(demesionattr) | |
for i in range(len(deme)): | |
if int(deme[i].lstrip("[").rstrip("]").strip()) >= int(self._Capacity[i]): | |
if self._Capacity[i] != "-1": | |
firstfieldinfo = list(fieldinfo.values())[0] | |
EdkLogger.error('Build', OPTION_VALUE_INVALID, "For Pcd %s, Array Index exceed the Array size. From %s Line %s \n " % | |
(".".join((self.TokenSpaceGuidCName, self.TokenCName)), firstfieldinfo[1],firstfieldinfo[2] )) | |
if hasattr(self,"DefaultValues"): | |
for demesionattr in self.DefaultValues: | |
fieldinfo = self.DefaultValues[demesionattr] | |
deme = ArrayIndex.findall(demesionattr) | |
for i in range(len(deme)): | |
if int(deme[i].lstrip("[").rstrip("]").strip()) >= int(self._Capacity[i]): | |
if self._Capacity[i] != "-1": | |
firstfieldinfo = list(fieldinfo.values())[0] | |
EdkLogger.error('Build', OPTION_VALUE_INVALID, "For Pcd %s, Array Index exceed the Array size. From %s Line %s \n " % | |
(".".join((self.TokenSpaceGuidCName, self.TokenCName)), firstfieldinfo[1],firstfieldinfo[2] )) | |
return self._Capacity | |
def PcdArraySize(self): | |
if self.Capacity[-1] == "-1": | |
return -1 | |
size = 1 | |
for de in self.Capacity: | |
size = size * int(de) | |
return size | |
@property | |
def DatumType(self): | |
return self._DatumType | |
@DatumType.setter | |
def DatumType(self,DataType): | |
self._DatumType = DataType | |
self._Capacity = None | |
@property | |
def BaseDatumType(self): | |
if self.IsArray(): | |
return self._DatumType[:self._DatumType.index("[")] | |
else: | |
return self._DatumType | |
def IsArray(self): | |
return True if len(self.Capacity) else False | |
def IsAggregateDatumType(self): | |
if self.DatumType in [TAB_UINT8, TAB_UINT16, TAB_UINT32, TAB_UINT64, TAB_VOID, "BOOLEAN"]: | |
return False | |
if self.IsArray() or StructPattern.match(self.DatumType): | |
return True | |
return False | |
def IsSimpleTypeArray(self): | |
if self.IsArray() and self.BaseDatumType in [TAB_UINT8, TAB_UINT16, TAB_UINT32, TAB_UINT64, "BOOLEAN"]: | |
return True | |
return False | |
@staticmethod | |
def GetPcdMaxSizeWorker(PcdString, MaxSize): | |
if PcdString.startswith("{") and PcdString.endswith("}"): | |
return max([len(PcdString.split(",")),MaxSize]) | |
if PcdString.startswith("\"") or PcdString.startswith("\'"): | |
return max([len(PcdString)-2+1,MaxSize]) | |
if PcdString.startswith("L\""): | |
return max([2*(len(PcdString)-3+1),MaxSize]) | |
return max([len(PcdString),MaxSize]) | |
## Get the maximum number of bytes | |
def GetPcdMaxSize(self): | |
if self.DatumType in TAB_PCD_NUMERIC_TYPES: | |
return MAX_SIZE_TYPE[self.DatumType] | |
MaxSize = int(self.MaxDatumSize, 10) if self.MaxDatumSize else 0 | |
if self.PcdValueFromFdf: | |
MaxSize = self.GetPcdMaxSizeWorker(self.PcdValueFromFdf,MaxSize) | |
if self.PcdValueFromComm: | |
MaxSize = self.GetPcdMaxSizeWorker(self.PcdValueFromComm,MaxSize) | |
if hasattr(self, "DefaultValueFromDec"): | |
MaxSize = self.GetPcdMaxSizeWorker(self.DefaultValueFromDec,MaxSize) | |
return MaxSize | |
## Get the number of bytes | |
def GetPcdSize(self): | |
if self.DatumType in TAB_PCD_NUMERIC_TYPES: | |
return MAX_SIZE_TYPE[self.DatumType] | |
if not self.DefaultValue: | |
return 1 | |
elif self.DefaultValue[0] == 'L': | |
return (len(self.DefaultValue) - 2) * 2 | |
elif self.DefaultValue[0] == '{': | |
return len(self.DefaultValue.split(',')) | |
else: | |
return len(self.DefaultValue) - 1 | |
## Convert the class to a string | |
# | |
# Convert each member of the class to string | |
# Organize to a single line format string | |
# | |
# @retval Rtn Formatted String | |
# | |
def __str__(self): | |
Rtn = '\tTokenCName=' + str(self.TokenCName) + ', ' + \ | |
'TokenSpaceGuidCName=' + str(self.TokenSpaceGuidCName) + ', ' + \ | |
'Type=' + str(self.Type) + ', ' + \ | |
'DatumType=' + str(self.DatumType) + ', ' + \ | |
'DefaultValue=' + str(self.DefaultValue) + ', ' + \ | |
'TokenValue=' + str(self.TokenValue) + ', ' + \ | |
'MaxDatumSize=' + str(self.MaxDatumSize) + ', ' | |
for Item in self.SkuInfoList.values(): | |
Rtn = Rtn + 'SkuId=' + Item.SkuId + ', ' + 'SkuIdName=' + Item.SkuIdName | |
Rtn = Rtn + ', IsOverrided=' + str(self.IsOverrided) | |
return Rtn | |
## Override __eq__ function | |
# | |
# Check whether pcds are the same | |
# | |
# @retval False The two pcds are different | |
# @retval True The two pcds are the same | |
# | |
def __eq__(self, Other): | |
return Other and self.TokenCName == Other.TokenCName and self.TokenSpaceGuidCName == Other.TokenSpaceGuidCName | |
## Override __hash__ function | |
# | |
# Use (TokenCName, TokenSpaceGuidCName) as key in hash table | |
# | |
# @retval truple() Key for hash table | |
# | |
def __hash__(self): | |
return hash((self.TokenCName, self.TokenSpaceGuidCName)) | |
@cached_property | |
def _fullname(self): | |
return ".".join((self.TokenSpaceGuidCName,self.TokenCName)) | |
def __lt__(self,pcd): | |
return self._fullname < pcd._fullname | |
def __gt__(self,pcd): | |
return self._fullname > pcd._fullname | |
def sharedcopy(self,new_pcd): | |
new_pcd.TokenCName = self.TokenCName | |
new_pcd.TokenSpaceGuidCName = self.TokenSpaceGuidCName | |
new_pcd.TokenSpaceGuidValue = self.TokenSpaceGuidValue | |
new_pcd.Type = self.Type | |
new_pcd.DatumType = self.DatumType | |
new_pcd.DefaultValue = self.DefaultValue | |
new_pcd.TokenValue = self.TokenValue | |
new_pcd.MaxDatumSize = self.MaxDatumSize | |
new_pcd.MaxSizeUserSet = self.MaxSizeUserSet | |
new_pcd.Phase = self.Phase | |
new_pcd.Pending = self.Pending | |
new_pcd.IsOverrided = self.IsOverrided | |
new_pcd.IsFromBinaryInf = self.IsFromBinaryInf | |
new_pcd.IsFromDsc = self.IsFromDsc | |
new_pcd.PcdValueFromComm = self.PcdValueFromComm | |
new_pcd.PcdValueFromFdf = self.PcdValueFromFdf | |
new_pcd.UserDefinedDefaultStoresFlag = self.UserDefinedDefaultStoresFlag | |
new_pcd.DscRawValue = self.DscRawValue | |
new_pcd.DscRawValueInfo = self.DscRawValueInfo | |
new_pcd.CustomAttribute = self.CustomAttribute | |
new_pcd.validateranges = [item for item in self.validateranges] | |
new_pcd.validlists = [item for item in self.validlists] | |
new_pcd.expressions = [item for item in self.expressions] | |
new_pcd.SkuInfoList = {key: copy.deepcopy(skuobj) for key,skuobj in self.SkuInfoList.items()} | |
return new_pcd | |
def __deepcopy__(self,memo): | |
new_pcd = PcdClassObject() | |
self.sharedcopy(new_pcd) | |
return new_pcd | |
class StructurePcd(PcdClassObject): | |
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): | |
if SkuInfoList is None: | |
SkuInfoList = {} | |
if validateranges is None: | |
validateranges = [] | |
if validlists is None: | |
validlists = [] | |
if expressions is None: | |
expressions = [] | |
if Packages is None: | |
Packages = [] | |
super(StructurePcd, self).__init__(Name, Guid, Type, DatumType, Value, Token, MaxDatumSize, SkuInfoList, IsOverrided, GuidValue, validateranges, validlists, expressions) | |
self.StructuredPcdIncludeFile = [] if StructuredPcdIncludeFile is None else StructuredPcdIncludeFile | |
self.PackageDecs = Packages | |
self.DefaultStoreName = [default_store] | |
self.DefaultValues = OrderedDict() | |
self.PcdMode = None | |
self.SkuOverrideValues = OrderedDict() | |
self.StructName = None | |
self.PcdDefineLineNo = 0 | |
self.PkgPath = "" | |
self.DefaultValueFromDec = "" | |
self.DefaultValueFromDecInfo = None | |
self.ValueChain = set() | |
self.PcdFieldValueFromComm = OrderedDict() | |
self.PcdFieldValueFromFdf = OrderedDict() | |
self.DefaultFromDSC=None | |
self.PcdFiledValueFromDscComponent = OrderedDict() | |
def __repr__(self): | |
return self.TypeName | |
def AddDefaultValue (self, FieldName, Value, FileName="", LineNo=0,DimensionAttr ="-1"): | |
if DimensionAttr not in self.DefaultValues: | |
self.DefaultValues[DimensionAttr] = collections.OrderedDict() | |
if FieldName in self.DefaultValues[DimensionAttr]: | |
del self.DefaultValues[DimensionAttr][FieldName] | |
self.DefaultValues[DimensionAttr][FieldName] = [Value.strip(), FileName, LineNo] | |
return self.DefaultValues[DimensionAttr][FieldName] | |
def SetDecDefaultValue(self, DefaultValue,decpath=None,lineno=None): | |
self.DefaultValueFromDec = DefaultValue | |
self.DefaultValueFromDecInfo = (decpath,lineno) | |
def AddOverrideValue (self, FieldName, Value, SkuName, DefaultStoreName, FileName="", LineNo=0, DimensionAttr = '-1'): | |
if SkuName not in self.SkuOverrideValues: | |
self.SkuOverrideValues[SkuName] = OrderedDict() | |
if DefaultStoreName not in self.SkuOverrideValues[SkuName]: | |
self.SkuOverrideValues[SkuName][DefaultStoreName] = OrderedDict() | |
if DimensionAttr not in self.SkuOverrideValues[SkuName][DefaultStoreName]: | |
self.SkuOverrideValues[SkuName][DefaultStoreName][DimensionAttr] = collections.OrderedDict() | |
if FieldName in self.SkuOverrideValues[SkuName][DefaultStoreName][DimensionAttr]: | |
del self.SkuOverrideValues[SkuName][DefaultStoreName][DimensionAttr][FieldName] | |
self.SkuOverrideValues[SkuName][DefaultStoreName][DimensionAttr][FieldName] = [Value.strip(), FileName, LineNo] | |
return self.SkuOverrideValues[SkuName][DefaultStoreName][DimensionAttr][FieldName] | |
def AddComponentOverrideValue(self,FieldName, Value, ModuleGuid, FileName="", LineNo=0, DimensionAttr = '-1'): | |
self.PcdFiledValueFromDscComponent.setdefault(ModuleGuid, OrderedDict()) | |
self.PcdFiledValueFromDscComponent[ModuleGuid].setdefault(DimensionAttr,OrderedDict()) | |
self.PcdFiledValueFromDscComponent[ModuleGuid][DimensionAttr][FieldName] = [Value.strip(), FileName, LineNo] | |
return self.PcdFiledValueFromDscComponent[ModuleGuid][DimensionAttr][FieldName] | |
def SetPcdMode (self, PcdMode): | |
self.PcdMode = PcdMode | |
def copy(self, PcdObject): | |
self.TokenCName = PcdObject.TokenCName if PcdObject.TokenCName else self.TokenCName | |
self.TokenSpaceGuidCName = PcdObject.TokenSpaceGuidCName if PcdObject.TokenSpaceGuidCName else PcdObject.TokenSpaceGuidCName | |
self.TokenSpaceGuidValue = PcdObject.TokenSpaceGuidValue if PcdObject.TokenSpaceGuidValue else self.TokenSpaceGuidValue | |
self.Type = PcdObject.Type if PcdObject.Type else self.Type | |
self._DatumType = PcdObject.DatumType if PcdObject.DatumType else self.DatumType | |
self.DefaultValue = PcdObject.DefaultValue if PcdObject.DefaultValue else self.DefaultValue | |
self.TokenValue = PcdObject.TokenValue if PcdObject.TokenValue else self.TokenValue | |
self.MaxDatumSize = PcdObject.MaxDatumSize if PcdObject.MaxDatumSize else self.MaxDatumSize | |
self.SkuInfoList = PcdObject.SkuInfoList if PcdObject.SkuInfoList else self.SkuInfoList | |
self.Phase = PcdObject.Phase if PcdObject.Phase else self.Phase | |
self.Pending = PcdObject.Pending if PcdObject.Pending else self.Pending | |
self.IsOverrided = PcdObject.IsOverrided if PcdObject.IsOverrided else self.IsOverrided | |
self.IsFromBinaryInf = PcdObject.IsFromBinaryInf if PcdObject.IsFromBinaryInf else self.IsFromBinaryInf | |
self.IsFromDsc = PcdObject.IsFromDsc if PcdObject.IsFromDsc else self.IsFromDsc | |
self.validateranges = PcdObject.validateranges if PcdObject.validateranges else self.validateranges | |
self.validlists = PcdObject.validlists if PcdObject.validlists else self.validlists | |
self.expressions = PcdObject.expressions if PcdObject.expressions else self.expressions | |
self.DscRawValue = PcdObject.DscRawValue if PcdObject.DscRawValue else self.DscRawValue | |
self.DscRawValueInfo = PcdObject.DscRawValueInfo if PcdObject.DscRawValueInfo else self.DscRawValueInfo | |
self.PcdValueFromComm = PcdObject.PcdValueFromComm if PcdObject.PcdValueFromComm else self.PcdValueFromComm | |
self.PcdValueFromFdf = PcdObject.PcdValueFromFdf if PcdObject.PcdValueFromFdf else self.PcdValueFromFdf | |
self.CustomAttribute = PcdObject.CustomAttribute if PcdObject.CustomAttribute else self.CustomAttribute | |
self.UserDefinedDefaultStoresFlag = PcdObject.UserDefinedDefaultStoresFlag if PcdObject.UserDefinedDefaultStoresFlag else self.UserDefinedDefaultStoresFlag | |
if isinstance(PcdObject, StructurePcd): | |
self.StructuredPcdIncludeFile = PcdObject.StructuredPcdIncludeFile if PcdObject.StructuredPcdIncludeFile else self.StructuredPcdIncludeFile | |
self.PackageDecs = PcdObject.PackageDecs if PcdObject.PackageDecs else self.PackageDecs | |
self.DefaultValues = PcdObject.DefaultValues if PcdObject.DefaultValues else self.DefaultValues | |
self.PcdMode = PcdObject.PcdMode if PcdObject.PcdMode else self.PcdMode | |
self.DefaultValueFromDec = PcdObject.DefaultValueFromDec if PcdObject.DefaultValueFromDec else self.DefaultValueFromDec | |
self.DefaultValueFromDecInfo = PcdObject.DefaultValueFromDecInfo if PcdObject.DefaultValueFromDecInfo else self.DefaultValueFromDecInfo | |
self.SkuOverrideValues = PcdObject.SkuOverrideValues if PcdObject.SkuOverrideValues else self.SkuOverrideValues | |
self.StructName = PcdObject.DatumType if PcdObject.DatumType else self.StructName | |
self.PcdDefineLineNo = PcdObject.PcdDefineLineNo if PcdObject.PcdDefineLineNo else self.PcdDefineLineNo | |
self.PkgPath = PcdObject.PkgPath if PcdObject.PkgPath else self.PkgPath | |
self.ValueChain = PcdObject.ValueChain if PcdObject.ValueChain else self.ValueChain | |
self.PcdFieldValueFromComm = PcdObject.PcdFieldValueFromComm if PcdObject.PcdFieldValueFromComm else self.PcdFieldValueFromComm | |
self.PcdFieldValueFromFdf = PcdObject.PcdFieldValueFromFdf if PcdObject.PcdFieldValueFromFdf else self.PcdFieldValueFromFdf | |
self.PcdFiledValueFromDscComponent = PcdObject.PcdFiledValueFromDscComponent if PcdObject.PcdFiledValueFromDscComponent else self.PcdFiledValueFromDscComponent | |
def __deepcopy__(self,memo): | |
new_pcd = StructurePcd() | |
self.sharedcopy(new_pcd) | |
new_pcd.DefaultValueFromDec = self.DefaultValueFromDec | |
new_pcd.DefaultValueFromDecInfo = self.DefaultValueFromDecInfo | |
new_pcd.PcdMode = self.PcdMode | |
new_pcd.StructName = self.DatumType | |
new_pcd.PcdDefineLineNo = self.PcdDefineLineNo | |
new_pcd.PkgPath = self.PkgPath | |
new_pcd.StructuredPcdIncludeFile = [item for item in self.StructuredPcdIncludeFile] | |
new_pcd.PackageDecs = [item for item in self.PackageDecs] | |
new_pcd.DefaultValues = CopyDict(self.DefaultValues) | |
new_pcd.DefaultFromDSC=CopyDict(self.DefaultFromDSC) | |
new_pcd.SkuOverrideValues = CopyDict(self.SkuOverrideValues) | |
new_pcd.PcdFieldValueFromComm = CopyDict(self.PcdFieldValueFromComm) | |
new_pcd.PcdFieldValueFromFdf = CopyDict(self.PcdFieldValueFromFdf) | |
new_pcd.PcdFiledValueFromDscComponent = CopyDict(self.PcdFiledValueFromDscComponent) | |
new_pcd.ValueChain = {item for item in self.ValueChain} | |
return new_pcd | |
LibraryClassObject = namedtuple('LibraryClassObject', ['LibraryClass','SupModList']) | |
class BuildData(object): | |
# dict used to convert PCD type in database to string used by build tool | |
_PCD_TYPE_STRING_ = { | |
MODEL_PCD_FIXED_AT_BUILD : TAB_PCDS_FIXED_AT_BUILD, | |
MODEL_PCD_PATCHABLE_IN_MODULE : TAB_PCDS_PATCHABLE_IN_MODULE, | |
MODEL_PCD_FEATURE_FLAG : TAB_PCDS_FEATURE_FLAG, | |
MODEL_PCD_DYNAMIC : TAB_PCDS_DYNAMIC, | |
MODEL_PCD_DYNAMIC_DEFAULT : TAB_PCDS_DYNAMIC, | |
MODEL_PCD_DYNAMIC_HII : TAB_PCDS_DYNAMIC_HII, | |
MODEL_PCD_DYNAMIC_VPD : TAB_PCDS_DYNAMIC_VPD, | |
MODEL_PCD_DYNAMIC_EX : TAB_PCDS_DYNAMIC_EX, | |
MODEL_PCD_DYNAMIC_EX_DEFAULT : TAB_PCDS_DYNAMIC_EX, | |
MODEL_PCD_DYNAMIC_EX_HII : TAB_PCDS_DYNAMIC_EX_HII, | |
MODEL_PCD_DYNAMIC_EX_VPD : TAB_PCDS_DYNAMIC_EX_VPD, | |
} | |
def UpdatePcdTypeDict(self): | |
if GlobalData.gCommandLineDefines.get(TAB_DSC_DEFINES_PCD_DYNAMIC_AS_DYNAMICEX,"FALSE").upper() == "TRUE": | |
self._PCD_TYPE_STRING_ = { | |
MODEL_PCD_FIXED_AT_BUILD : TAB_PCDS_FIXED_AT_BUILD, | |
MODEL_PCD_PATCHABLE_IN_MODULE : TAB_PCDS_PATCHABLE_IN_MODULE, | |
MODEL_PCD_FEATURE_FLAG : TAB_PCDS_FEATURE_FLAG, | |
MODEL_PCD_DYNAMIC : TAB_PCDS_DYNAMIC_EX, | |
MODEL_PCD_DYNAMIC_DEFAULT : TAB_PCDS_DYNAMIC_EX, | |
MODEL_PCD_DYNAMIC_HII : TAB_PCDS_DYNAMIC_EX_HII, | |
MODEL_PCD_DYNAMIC_VPD : TAB_PCDS_DYNAMIC_EX_VPD, | |
MODEL_PCD_DYNAMIC_EX : TAB_PCDS_DYNAMIC_EX, | |
MODEL_PCD_DYNAMIC_EX_DEFAULT : TAB_PCDS_DYNAMIC_EX, | |
MODEL_PCD_DYNAMIC_EX_HII : TAB_PCDS_DYNAMIC_EX_HII, | |
MODEL_PCD_DYNAMIC_EX_VPD : TAB_PCDS_DYNAMIC_EX_VPD, | |
} | |
## Convert the class to a string | |
# | |
# Convert member MetaFile of the class to a string | |
# | |
# @retval string Formatted String | |
# | |
def __str__(self): | |
return str(self.MetaFile) | |
## Override __eq__ function | |
# | |
# Check whether ModuleBuildClassObjects are the same | |
# | |
# @retval False The two ModuleBuildClassObjects are different | |
# @retval True The two ModuleBuildClassObjects are the same | |
# | |
def __eq__(self, Other): | |
return self.MetaFile == Other | |
## Override __hash__ function | |
# | |
# Use MetaFile as key in hash table | |
# | |
# @retval string Key for hash table | |
# | |
def __hash__(self): | |
return hash(self.MetaFile) | |
## ModuleBuildClassObject | |
# | |
# This Class defines ModuleBuildClass | |
# | |
# @param object: Inherited from object class | |
# | |
# @var MetaFile: To store value for module meta file path | |
# @var BaseName: To store value for BaseName | |
# @var ModuleType: To store value for ModuleType | |
# @var Guid: To store value for Guid | |
# @var Version: To store value for Version | |
# @var PcdIsDriver: To store value for PcdIsDriver | |
# @var BinaryModule: To store value for BinaryModule | |
# @var CustomMakefile: To store value for CustomMakefile | |
# @var Specification: To store value for Specification | |
# @var Shadow To store value for Shadow | |
# @var LibraryClass: To store value for LibraryClass, it is a list structure as | |
# [ LibraryClassObject, ...] | |
# @var ModuleEntryPointList: To store value for ModuleEntryPointList | |
# @var ModuleUnloadImageList: To store value for ModuleUnloadImageList | |
# @var ConstructorList: To store value for ConstructorList | |
# @var DestructorList: To store value for DestructorList | |
# @var Binaries: To store value for Binaries, it is a list structure as | |
# [ ModuleBinaryClassObject, ...] | |
# @var Sources: To store value for Sources, it is a list structure as | |
# [ ModuleSourceFilesClassObject, ... ] | |
# @var LibraryClasses: To store value for LibraryClasses, it is a set structure as | |
# { [LibraryClassName, ModuleType] : LibraryClassInfFile } | |
# @var Protocols: To store value for Protocols, it is a list structure as | |
# [ ProtocolName, ... ] | |
# @var Ppis: To store value for Ppis, it is a list structure as | |
# [ PpiName, ... ] | |
# @var Guids: To store value for Guids, it is a list structure as | |
# [ GuidName, ... ] | |
# @var Includes: To store value for Includes, it is a list structure as | |
# [ IncludePath, ... ] | |
# @var Packages: To store value for Packages, it is a list structure as | |
# [ DecFileName, ... ] | |
# @var Pcds: To store value for Pcds, it is a set structure as | |
# { [(PcdCName, PcdGuidCName)] : PcdClassObject} | |
# @var BuildOptions: To store value for BuildOptions, it is a set structure as | |
# { [BuildOptionKey] : BuildOptionValue} | |
# @var Depex: To store value for Depex | |
# | |
class ModuleBuildClassObject(BuildData): | |
def __init__(self): | |
self.AutoGenVersion = 0 | |
self.MetaFile = '' | |
self.BaseName = '' | |
self.ModuleType = '' | |
self.Guid = '' | |
self.Version = '' | |
self.PcdIsDriver = '' | |
self.BinaryModule = '' | |
self.Shadow = '' | |
self.CustomMakefile = {} | |
self.Specification = {} | |
self.LibraryClass = [] | |
self.ModuleEntryPointList = [] | |
self.ModuleUnloadImageList = [] | |
self.ConstructorList = [] | |
self.DestructorList = [] | |
self.Binaries = [] | |
self.Sources = [] | |
self.LibraryClasses = OrderedDict() | |
self.Libraries = [] | |
self.Protocols = [] | |
self.Ppis = [] | |
self.Guids = [] | |
self.Includes = [] | |
self.Packages = [] | |
self.Pcds = {} | |
self.BuildOptions = {} | |
self.Depex = {} | |
self.StrPcdSet = [] | |
self.StrPcdOverallValue = {} | |
## PackageBuildClassObject | |
# | |
# This Class defines PackageBuildClass | |
# | |
# @param object: Inherited from object class | |
# | |
# @var MetaFile: To store value for package meta file path | |
# @var PackageName: To store value for PackageName | |
# @var Guid: To store value for Guid | |
# @var Version: To store value for Version | |
# @var Protocols: To store value for Protocols, it is a set structure as | |
# { [ProtocolName] : Protocol Guid, ... } | |
# @var Ppis: To store value for Ppis, it is a set structure as | |
# { [PpiName] : Ppi Guid, ... } | |
# @var Guids: To store value for Guids, it is a set structure as | |
# { [GuidName] : Guid, ... } | |
# @var Includes: To store value for Includes, it is a list structure as | |
# [ IncludePath, ... ] | |
# @var LibraryClasses: To store value for LibraryClasses, it is a set structure as | |
# { [LibraryClassName] : LibraryClassInfFile } | |
# @var Pcds: To store value for Pcds, it is a set structure as | |
# { [(PcdCName, PcdGuidCName)] : PcdClassObject} | |
# | |
class PackageBuildClassObject(BuildData): | |
def __init__(self): | |
self.MetaFile = '' | |
self.PackageName = '' | |
self.Guid = '' | |
self.Version = '' | |
self.Protocols = {} | |
self.Ppis = {} | |
self.Guids = {} | |
self.Includes = [] | |
self.LibraryClasses = {} | |
self.Pcds = {} | |
## PlatformBuildClassObject | |
# | |
# This Class defines PlatformBuildClass | |
# | |
# @param object: Inherited from object class | |
# | |
# @var MetaFile: To store value for platform meta-file path | |
# @var PlatformName: To store value for PlatformName | |
# @var Guid: To store value for Guid | |
# @var Version: To store value for Version | |
# @var DscSpecification: To store value for DscSpecification | |
# @var OutputDirectory: To store value for OutputDirectory | |
# @var FlashDefinition: To store value for FlashDefinition | |
# @var BuildNumber: To store value for BuildNumber | |
# @var SkuIds: To store value for SkuIds, it is a set structure as | |
# { 'SkuName' : SkuId, '!include' : includefilename, ...} | |
# @var Modules: To store value for Modules, it is a list structure as | |
# [ InfFileName, ... ] | |
# @var Libraries: To store value for Libraries, it is a list structure as | |
# [ InfFileName, ... ] | |
# @var LibraryClasses: To store value for LibraryClasses, it is a set structure as | |
# { (LibraryClassName, ModuleType) : LibraryClassInfFile } | |
# @var Pcds: To store value for Pcds, it is a set structure as | |
# { [(PcdCName, PcdGuidCName)] : PcdClassObject } | |
# @var BuildOptions: To store value for BuildOptions, it is a set structure as | |
# { [BuildOptionKey] : BuildOptionValue } | |
# | |
class PlatformBuildClassObject(BuildData): | |
def __init__(self): | |
self.MetaFile = '' | |
self.PlatformName = '' | |
self.Guid = '' | |
self.Version = '' | |
self.DscSpecification = '' | |
self.OutputDirectory = '' | |
self.FlashDefinition = '' | |
self.BuildNumber = '' | |
self.SkuIds = {} | |
self.Modules = [] | |
self.LibraryInstances = [] | |
self.LibraryClasses = {} | |
self.Libraries = {} | |
self.Pcds = {} | |
self.BuildOptions = {} |