# @param Platform (not used for DscBuildData)\r
# @param Macros Macros used for replacement in DSC file\r
#\r
- def __init__(self, FilePath, RawData, BuildDataBase, Arch='COMMON', Platform='DUMMY', Macros={}):\r
+ def __init__(self, FilePath, RawData, BuildDataBase, Arch='COMMON', Target=None, Toolchain=None):\r
self.MetaFile = FilePath\r
self._RawData = RawData\r
self._Bdb = BuildDataBase\r
self._Arch = Arch\r
- self._Macros = Macros\r
+ self._Target = Target\r
+ self._Toolchain = Toolchain\r
self._Clear()\r
- RecordList = self._RawData[MODEL_META_DATA_DEFINE, self._Arch]\r
- for Record in RecordList:\r
- GlobalData.gEdkGlobal[Record[0]] = Record[1]\r
- \r
- RecordList = self._RawData[MODEL_META_DATA_GLOBAL_DEFINE, self._Arch]\r
- for Record in RecordList:\r
- GlobalData.gGlobalDefines[Record[0]] = Record[1]\r
\r
## XXX[key] = value\r
def __setitem__(self, key, value):\r
self._RFCLanguages = None\r
self._ISOLanguages = None\r
self._VpdToolGuid = None\r
+ self.__Macros = None\r
+\r
+ ## Get current effective macros\r
+ def _GetMacros(self):\r
+ if self.__Macros == None:\r
+ self.__Macros = {}\r
+ self.__Macros.update(GlobalData.gPlatformDefines)\r
+ self.__Macros.update(GlobalData.gGlobalDefines)\r
+ self.__Macros.update(GlobalData.gCommandLineDefines)\r
+ return self.__Macros\r
\r
## Get architecture\r
def _GetArch(self):\r
def _GetHeaderInfo(self):\r
RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch]\r
for Record in RecordList:\r
- Name = Record[0]\r
+ Name = Record[1]\r
# items defined _PROPERTY_ don't need additional processing\r
if Name in self:\r
- self[Name] = Record[1]\r
+ self[Name] = Record[2]\r
# some special items in [Defines] section need special treatment\r
elif Name == TAB_DSC_DEFINES_OUTPUT_DIRECTORY:\r
- self._OutputDirectory = NormPath(Record[1], self._Macros)\r
+ self._OutputDirectory = NormPath(Record[2], self._Macros)\r
if ' ' in self._OutputDirectory:\r
EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "No space is allowed in OUTPUT_DIRECTORY",\r
File=self.MetaFile, Line=Record[-1],\r
ExtraData=self._OutputDirectory)\r
elif Name == TAB_DSC_DEFINES_FLASH_DEFINITION:\r
- self._FlashDefinition = PathClass(NormPath(Record[1], self._Macros), GlobalData.gWorkspace)\r
+ self._FlashDefinition = PathClass(NormPath(Record[2], self._Macros), GlobalData.gWorkspace)\r
ErrorCode, ErrorInfo = self._FlashDefinition.Validate('.fdf')\r
if ErrorCode != 0:\r
EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=Record[-1],\r
ExtraData=ErrorInfo)\r
elif Name == TAB_DSC_DEFINES_SUPPORTED_ARCHITECTURES:\r
- self._SupArchList = GetSplitValueList(Record[1], TAB_VALUE_SPLIT)\r
+ self._SupArchList = GetSplitValueList(Record[2], TAB_VALUE_SPLIT)\r
elif Name == TAB_DSC_DEFINES_BUILD_TARGETS:\r
- self._BuildTargets = GetSplitValueList(Record[1])\r
+ self._BuildTargets = GetSplitValueList(Record[2])\r
elif Name == TAB_DSC_DEFINES_SKUID_IDENTIFIER:\r
if self._SkuName == None:\r
- self._SkuName = Record[1]\r
+ self._SkuName = Record[2]\r
elif Name == TAB_FIX_LOAD_TOP_MEMORY_ADDRESS:\r
- self._LoadFixAddress = Record[1]\r
+ try:\r
+ self._LoadFixAddress = int (Record[2], 0)\r
+ except:\r
+ EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS %s is not valid dec or hex string" % (Record[2]))\r
elif Name == TAB_DSC_DEFINES_RFC_LANGUAGES:\r
- if not Record[1] or Record[1][0] != '"' or Record[1][-1] != '"' or len(Record[1]) == 1:\r
+ if not Record[2] or Record[2][0] != '"' or Record[2][-1] != '"' or len(Record[2]) == 1:\r
EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'language code for RFC_LANGUAGES must have double quotes around it, for example: RFC_LANGUAGES = "en-us;zh-hans"',\r
File=self.MetaFile, Line=Record[-1])\r
- LanguageCodes = Record[1][1:-1]\r
+ LanguageCodes = Record[2][1:-1]\r
if not LanguageCodes:\r
EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'one or more RFC4646 format language code must be provided for RFC_LANGUAGES statement',\r
File=self.MetaFile, Line=Record[-1]) \r
File=self.MetaFile, Line=Record[-1]) \r
self._RFCLanguages = LanguageList\r
elif Name == TAB_DSC_DEFINES_ISO_LANGUAGES:\r
- if not Record[1] or Record[1][0] != '"' or Record[1][-1] != '"' or len(Record[1]) == 1:\r
+ if not Record[2] or Record[2][0] != '"' or Record[2][-1] != '"' or len(Record[2]) == 1:\r
EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'language code for ISO_LANGUAGES must have double quotes around it, for example: ISO_LANGUAGES = "engchn"',\r
File=self.MetaFile, Line=Record[-1])\r
- LanguageCodes = Record[1][1:-1]\r
+ LanguageCodes = Record[2][1:-1]\r
if not LanguageCodes:\r
EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'one or more ISO639-2 format language code must be provided for ISO_LANGUAGES statement',\r
File=self.MetaFile, Line=Record[-1]) \r
# for VPD_TOOL_GUID is correct.\r
#\r
try:\r
- uuid.UUID(Record[1])\r
+ uuid.UUID(Record[2])\r
except:\r
EdkLogger.error("build", FORMAT_INVALID, "Invalid GUID format for VPD_TOOL_GUID", File=self.MetaFile)\r
- self._VpdToolGuid = Record[1] \r
+ self._VpdToolGuid = Record[2] \r
# set _Header to non-None in order to avoid database re-querying\r
self._Header = 'DUMMY'\r
\r
if self._LoadFixAddress == None:\r
if self._Header == None:\r
self._GetHeaderInfo()\r
+\r
if self._LoadFixAddress == None:\r
- self._LoadFixAddress = ''\r
+ self._LoadFixAddress = self._Macros.get(TAB_FIX_LOAD_TOP_MEMORY_ADDRESS, '0')\r
+\r
+ try:\r
+ self._LoadFixAddress = int (self._LoadFixAddress, 0)\r
+ except:\r
+ EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS %s is not valid dec or hex string" % (self._LoadFixAddress))\r
+ if self._LoadFixAddress < 0:\r
+ EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS is set to the invalid negative value %s" % (self._LoadFixAddress))\r
+ if self._LoadFixAddress != 0xFFFFFFFFFFFFFFFF and self._LoadFixAddress % 0x1000 != 0:\r
+ EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS is set to the invalid unaligned 4K value %s" % (self._LoadFixAddress))\r
return self._LoadFixAddress\r
\r
## Retrieve RFCLanguage filter\r
if self._ISOLanguages == None:\r
self._ISOLanguages = []\r
return self._ISOLanguages\r
-\r
## Retrieve the GUID string for VPD tool\r
def _GetVpdToolGuid(self):\r
if self._VpdToolGuid == None:\r
## Retrieve [SkuIds] section information\r
def _GetSkuIds(self):\r
if self._SkuIds == None:\r
- self._SkuIds = {}\r
- RecordList = self._RawData[MODEL_EFI_SKU_ID]\r
+ self._SkuIds = sdict()\r
+ RecordList = self._RawData[MODEL_EFI_SKU_ID, self._Arch]\r
for Record in RecordList:\r
if Record[0] in [None, '']:\r
EdkLogger.error('build', FORMAT_INVALID, 'No Sku ID number',\r
\r
self._Modules = sdict()\r
RecordList = self._RawData[MODEL_META_DATA_COMPONENT, self._Arch]\r
- Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource}\r
- Macros.update(self._Macros)\r
+ Macros = self._Macros\r
+ Macros["EDK_SOURCE"] = GlobalData.gEcpSource\r
for Record in RecordList:\r
ModuleFile = PathClass(NormPath(Record[0], Macros), GlobalData.gWorkspace, Arch=self._Arch)\r
ModuleId = Record[5]\r
LibraryClassDict = tdict(True, 3)\r
# track all library class names\r
LibraryClassSet = set()\r
- RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch]\r
- Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource}\r
- Macros.update(self._Macros)\r
+ RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch, None, -1]\r
+ Macros = self._Macros\r
for Record in RecordList:\r
LibraryClass, LibraryInstance, Dummy, Arch, ModuleType, Dummy, LineNo = Record\r
if LibraryClass == '' or LibraryClass == 'NULL':\r
continue\r
self._LibraryClasses[LibraryClass, ModuleType] = LibraryInstance\r
\r
- # for EDK style library instances, which are listed in different section\r
+ # for Edk style library instances, which are listed in different section\r
+ Macros["EDK_SOURCE"] = GlobalData.gEcpSource\r
RecordList = self._RawData[MODEL_EFI_LIBRARY_INSTANCE, self._Arch]\r
for Record in RecordList:\r
File = PathClass(NormPath(Record[0], Macros), GlobalData.gWorkspace, Arch=self._Arch)\r
# to parse it here. (self._Bdb[] will trigger a file parse if it\r
# hasn't been parsed)\r
#\r
- Library = self._Bdb[File, self._Arch]\r
+ Library = self._Bdb[File, self._Arch, self._Target, self._Toolchain]\r
self._LibraryClasses[Library.BaseName, ':dummy:'] = Library\r
return self._LibraryClasses\r
\r
## Retrieve all PCD settings in platform\r
def _GetPcds(self):\r
if self._Pcds == None:\r
- self._Pcds = {}\r
+ self._Pcds = sdict()\r
self._Pcds.update(self._GetPcd(MODEL_PCD_FIXED_AT_BUILD))\r
self._Pcds.update(self._GetPcd(MODEL_PCD_PATCHABLE_IN_MODULE))\r
self._Pcds.update(self._GetPcd(MODEL_PCD_FEATURE_FLAG))\r
## Retrieve [BuildOptions]\r
def _GetBuildOptions(self):\r
if self._BuildOptions == None:\r
- self._BuildOptions = {}\r
+ self._BuildOptions = sdict()\r
#\r
# Retrieve build option for EDKII style module\r
#\r
- RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, 'COMMON', EDKII_NAME]\r
+ RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, self._Arch, EDKII_NAME]\r
for ToolChainFamily, ToolChain, Option, Dummy1, Dummy2, Dummy3, Dummy4 in RecordList:\r
self._BuildOptions[ToolChainFamily, ToolChain, EDKII_NAME] = Option\r
#\r
# Retrieve build option for EDK style module\r
#\r
- RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, 'COMMON', EDK_NAME] \r
+ RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, self._Arch, EDK_NAME] \r
for ToolChainFamily, ToolChain, Option, Dummy1, Dummy2, Dummy3, Dummy4 in RecordList:\r
self._BuildOptions[ToolChainFamily, ToolChain, EDK_NAME] = Option\r
return self._BuildOptions\r
# @retval a dict object contains settings of given PCD type\r
#\r
def _GetPcd(self, Type):\r
- Pcds = {}\r
+ Pcds = sdict()\r
#\r
# tdict is a special dict kind of type, used for selecting correct\r
# PCD settings for certain ARCH\r
# @retval a dict object contains settings of given PCD type\r
#\r
def _GetDynamicPcd(self, Type):\r
- Pcds = {}\r
+ Pcds = sdict()\r
#\r
# tdict is a special dict kind of type, used for selecting correct\r
# PCD settings for certain ARCH and SKU\r
# @retval a dict object contains settings of given PCD type\r
#\r
def _GetDynamicHiiPcd(self, Type):\r
- Pcds = {}\r
+ Pcds = sdict()\r
#\r
# tdict is a special dict kind of type, used for selecting correct\r
# PCD settings for certain ARCH and SKU\r
# @retval a dict object contains settings of given PCD type\r
#\r
def _GetDynamicVpdPcd(self, Type):\r
- Pcds = {}\r
+ Pcds = sdict()\r
#\r
# tdict is a special dict kind of type, used for selecting correct\r
# PCD settings for certain ARCH and SKU\r
self.Pcds[Name, Guid] = PcdClassObject(Name, Guid, '', '', '', '', '', {}, False, None)\r
self.Pcds[Name, Guid].DefaultValue = Value\r
\r
+ _Macros = property(_GetMacros)\r
Arch = property(_GetArch, _SetArch)\r
Platform = property(_GetPlatformName)\r
PlatformName = property(_GetPlatformName)\r
# @param Platform (not used for DecBuildData)\r
# @param Macros Macros used for replacement in DSC file\r
#\r
- def __init__(self, File, RawData, BuildDataBase, Arch='COMMON', Platform='DUMMY', Macros={}):\r
+ def __init__(self, File, RawData, BuildDataBase, Arch='COMMON', Target=None, Toolchain=None):\r
self.MetaFile = File\r
self._PackageDir = File.Dir\r
self._RawData = RawData\r
self._Bdb = BuildDataBase\r
self._Arch = Arch\r
- self._Macros = Macros\r
+ self._Target = Target\r
+ self._Toolchain = Toolchain\r
self._Clear()\r
\r
## XXX[key] = value\r
self._Includes = None\r
self._LibraryClasses = None\r
self._Pcds = None\r
+ self.__Macros = None\r
+\r
+ ## Get current effective macros\r
+ def _GetMacros(self):\r
+ if self.__Macros == None:\r
+ self.__Macros = {}\r
+ self.__Macros.update(GlobalData.gGlobalDefines)\r
+ return self.__Macros\r
\r
## Get architecture\r
def _GetArch(self):\r
# (Retriving all [Defines] information in one-shot is just to save time.)\r
#\r
def _GetHeaderInfo(self):\r
- RecordList = self._RawData[MODEL_META_DATA_HEADER]\r
+ RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch]\r
for Record in RecordList:\r
- Name = Record[0]\r
+ Name = Record[1]\r
if Name in self:\r
- self[Name] = Record[1]\r
+ self[Name] = Record[2]\r
self._Header = 'DUMMY'\r
\r
## Retrieve package name\r
if self._Includes == None:\r
self._Includes = []\r
RecordList = self._RawData[MODEL_EFI_INCLUDE, self._Arch]\r
- Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource}\r
- Macros.update(self._Macros)\r
+ Macros = self._Macros\r
+ Macros["EDK_SOURCE"] = GlobalData.gEcpSource\r
for Record in RecordList:\r
File = PathClass(NormPath(Record[0], Macros), self._PackageDir, Arch=self._Arch)\r
LineNo = Record[-1]\r
LibraryClassDict = tdict(True)\r
LibraryClassSet = set()\r
RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch]\r
- Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource}\r
- Macros.update(self._Macros)\r
+ Macros = self._Macros\r
for LibraryClass, File, Dummy, Arch, ID, LineNo in RecordList:\r
File = PathClass(NormPath(File, Macros), self._PackageDir, Arch=self._Arch)\r
# check the file validation\r
## Retrieve PCD declarations\r
def _GetPcds(self):\r
if self._Pcds == None:\r
- self._Pcds = {}\r
+ self._Pcds = sdict()\r
self._Pcds.update(self._GetPcd(MODEL_PCD_FIXED_AT_BUILD))\r
self._Pcds.update(self._GetPcd(MODEL_PCD_PATCHABLE_IN_MODULE))\r
self._Pcds.update(self._GetPcd(MODEL_PCD_FEATURE_FLAG))\r
\r
## Retrieve PCD declarations for given type\r
def _GetPcd(self, Type):\r
- Pcds = {}\r
+ Pcds = sdict()\r
#\r
# tdict is a special kind of dict, used for selecting correct\r
# PCD declaration for given ARCH\r
return Pcds\r
\r
\r
+ _Macros = property(_GetMacros)\r
Arch = property(_GetArch, _SetArch)\r
PackageName = property(_GetPackageName)\r
Guid = property(_GetFileGuid)\r
#\r
# Optional Fields\r
#\r
- TAB_INF_DEFINES_INF_VERSION : "_AutoGenVersion",\r
+ #TAB_INF_DEFINES_INF_VERSION : "_AutoGenVersion",\r
TAB_INF_DEFINES_COMPONENT_TYPE : "_ComponentType",\r
TAB_INF_DEFINES_MAKEFILE_NAME : "_MakefileName",\r
#TAB_INF_DEFINES_CUSTOM_MAKEFILE : "_CustomMakefile",\r
# @param Platform The name of platform employing this module\r
# @param Macros Macros used for replacement in DSC file\r
#\r
- def __init__(self, FilePath, RawData, BuildDatabase, Arch='COMMON', Platform='COMMON', Macros={}):\r
+ def __init__(self, FilePath, RawData, BuildDatabase, Arch='COMMON', Target=None, Toolchain=None):\r
self.MetaFile = FilePath\r
self._ModuleDir = FilePath.Dir\r
self._RawData = RawData\r
self._Bdb = BuildDatabase\r
self._Arch = Arch\r
+ self._Target = Target\r
+ self._Toolchain = Toolchain\r
self._Platform = 'COMMON'\r
- self._Macros = Macros\r
self._SourceOverridePath = None\r
if FilePath.Key in GlobalData.gOverrideDir:\r
self._SourceOverridePath = GlobalData.gOverrideDir[FilePath.Key]\r
self._BuildOptions = None\r
self._Depex = None\r
self._DepexExpression = None\r
- #self._SourceOverridePath = None\r
+ self.__Macros = None\r
+\r
+ ## Get current effective macros\r
+ def _GetMacros(self):\r
+ if self.__Macros == None:\r
+ self.__Macros = {}\r
+ # EDK_GLOBAL defined macros can be applied to EDK modoule\r
+ if self.AutoGenVersion < 0x00010005:\r
+ self.__Macros.update(GlobalData.gEdkGlobal)\r
+ self.__Macros.update(GlobalData.gGlobalDefines)\r
+ return self.__Macros\r
\r
## Get architecture\r
def _GetArch(self):\r
def _GetHeaderInfo(self):\r
RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch, self._Platform]\r
for Record in RecordList:\r
- Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)\r
- Name = Record[0]\r
+ Name, Value = Record[1], ReplaceMacro(Record[2], self._Macros, False)\r
# items defined _PROPERTY_ don't need additional processing\r
if Name in self:\r
- self[Name] = Record[1]\r
+ self[Name] = Value\r
# some special items in [Defines] section need special treatment\r
elif Name in ('EFI_SPECIFICATION_VERSION', 'UEFI_SPECIFICATION_VERSION', 'EDK_RELEASE_VERSION', 'PI_SPECIFICATION_VERSION'):\r
if Name in ('EFI_SPECIFICATION_VERSION', 'UEFI_SPECIFICATION_VERSION'):\r
Name = 'UEFI_SPECIFICATION_VERSION'\r
if self._Specification == None:\r
self._Specification = sdict()\r
- self._Specification[Name] = GetHexVerValue(Record[1])\r
+ self._Specification[Name] = GetHexVerValue(Value)\r
if self._Specification[Name] == None:\r
EdkLogger.error("build", FORMAT_NOT_SUPPORTED,\r
- "'%s' format is not supported for %s" % (Record[1], Name),\r
+ "'%s' format is not supported for %s" % (Value, Name),\r
File=self.MetaFile, Line=Record[-1])\r
elif Name == 'LIBRARY_CLASS':\r
if self._LibraryClass == None:\r
self._LibraryClass = []\r
- ValueList = GetSplitValueList(Record[1])\r
+ ValueList = GetSplitValueList(Value)\r
LibraryClass = ValueList[0]\r
if len(ValueList) > 1:\r
SupModuleList = GetSplitValueList(ValueList[1], ' ')\r
elif Name == 'ENTRY_POINT':\r
if self._ModuleEntryPointList == None:\r
self._ModuleEntryPointList = []\r
- self._ModuleEntryPointList.append(Record[1])\r
+ self._ModuleEntryPointList.append(Value)\r
elif Name == 'UNLOAD_IMAGE':\r
if self._ModuleUnloadImageList == None:\r
self._ModuleUnloadImageList = []\r
- if Record[1] == '':\r
+ if not Value:\r
continue\r
- self._ModuleUnloadImageList.append(Record[1])\r
+ self._ModuleUnloadImageList.append(Value)\r
elif Name == 'CONSTRUCTOR':\r
if self._ConstructorList == None:\r
self._ConstructorList = []\r
- if Record[1] == '':\r
+ if not Value:\r
continue\r
- self._ConstructorList.append(Record[1])\r
+ self._ConstructorList.append(Value)\r
elif Name == 'DESTRUCTOR':\r
if self._DestructorList == None:\r
self._DestructorList = []\r
- if Record[1] == '':\r
+ if not Value:\r
continue\r
- self._DestructorList.append(Record[1])\r
+ self._DestructorList.append(Value)\r
elif Name == TAB_INF_DEFINES_CUSTOM_MAKEFILE:\r
- TokenList = GetSplitValueList(Record[1])\r
+ TokenList = GetSplitValueList(Value)\r
if self._CustomMakefile == None:\r
self._CustomMakefile = {}\r
if len(TokenList) < 2:\r
else:\r
if self._Defs == None:\r
self._Defs = sdict()\r
- self._Defs[Name] = Record[1]\r
+ self._Defs[Name] = Value\r
\r
#\r
- # Retrieve information in sections specific to EDK.x modules\r
+ # Retrieve information in sections specific to Edk.x modules\r
#\r
- if self._AutoGenVersion >= 0x00010005: # _AutoGenVersion may be None, which is less than anything\r
+ if self.AutoGenVersion >= 0x00010005:\r
if not self._ModuleType:\r
EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE,\r
"MODULE_TYPE is not given", File=self.MetaFile)\r
if self._ModuleType not in SUP_MODULE_LIST:\r
RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch, self._Platform]\r
for Record in RecordList:\r
- Name = Record[0]\r
+ Name = Record[1]\r
if Name == "MODULE_TYPE":\r
LineNo = Record[6]\r
break\r
EdkLogger.error("build", FORMAT_NOT_SUPPORTED,\r
"MODULE_TYPE %s is not supported for EDK II, valid values are:\n %s" % (self._ModuleType,' '.join(l for l in SUP_MODULE_LIST)), \r
- File=self.MetaFile, Line=LineNo) \r
+ File=self.MetaFile, Line=LineNo)\r
if (self._Specification == None) or (not 'PI_SPECIFICATION_VERSION' in self._Specification) or (int(self._Specification['PI_SPECIFICATION_VERSION'], 16) < 0x0001000A):\r
if self._ModuleType == SUP_MODULE_SMM_CORE:\r
EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "SMM_CORE module type can't be used in the module with PI_SPECIFICATION_VERSION less than 0x0001000A", File=self.MetaFile) \r
if self.Sources == None:\r
self._Sources = []\r
self._Sources.append(File)\r
- else:\r
- self._BuildType = self._ComponentType.upper()\r
+ else: \r
if not self._ComponentType:\r
EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE,\r
"COMPONENT_TYPE is not given", File=self.MetaFile)\r
+ self._BuildType = self._ComponentType.upper() \r
if self._ComponentType in self._MODULE_TYPE_:\r
self._ModuleType = self._MODULE_TYPE_[self._ComponentType]\r
if self._ComponentType == 'LIBRARY':\r
self._LibraryClass = [LibraryClassObject(self._BaseName, SUP_MODULE_LIST)]\r
# make use some [nmake] section macros\r
+ Macros = self._Macros\r
+ Macros["EDK_SOURCE"] = GlobalData.gEcpSource\r
+ Macros['PROCESSOR'] = self._Arch\r
RecordList = self._RawData[MODEL_META_DATA_NMAKE, self._Arch, self._Platform]\r
for Name,Value,Dummy,Arch,Platform,ID,LineNo in RecordList:\r
- Value = Value.replace('$(PROCESSOR)', self._Arch)\r
- Name = Name.replace('$(PROCESSOR)', self._Arch)\r
- Name, Value = ReplaceMacros((Name, Value), GlobalData.gEdkGlobal, True)\r
+ Value = ReplaceMacro(Value, Macros, True)\r
if Name == "IMAGE_ENTRY_POINT":\r
if self._ModuleEntryPointList == None:\r
self._ModuleEntryPointList = []\r
self._ModuleEntryPointList.append(Value)\r
elif Name == "DPX_SOURCE":\r
- Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource}\r
- Macros.update(self._Macros)\r
- File = PathClass(NormPath(Value, Macros), self._ModuleDir, Arch=self._Arch)\r
+ File = PathClass(NormPath(Value), self._ModuleDir, Arch=self._Arch)\r
# check the file validation\r
ErrorCode, ErrorInfo = File.Validate(".dxs", CaseSensitive=False)\r
if ErrorCode != 0:\r
else:\r
Tool = ToolList[0]\r
ToolChain = "*_*_*_%s_FLAGS" % Tool\r
- ToolChainFamily = 'MSFT' # EDK.x only support MSFT tool chain\r
+ ToolChainFamily = 'MSFT' # Edk.x only support MSFT tool chain\r
#ignore not replaced macros in value\r
- ValueList = GetSplitValueList(' ' + Value, '/D')\r
+ ValueList = GetSplitList(' ' + Value, '/D')\r
Dummy = ValueList[0]\r
for Index in range(1, len(ValueList)):\r
if ValueList[Index][-1] == '=' or ValueList[Index] == '':\r
## Retrieve file version\r
def _GetInfVersion(self):\r
if self._AutoGenVersion == None:\r
- if self._Header_ == None:\r
- self._GetHeaderInfo()\r
+ RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch, self._Platform]\r
+ for Record in RecordList:\r
+ if Record[1] == TAB_INF_DEFINES_INF_VERSION:\r
+ self._AutoGenVersion = int(Record[2], 0)\r
+ break\r
if self._AutoGenVersion == None:\r
self._AutoGenVersion = 0x00010000\r
return self._AutoGenVersion\r
if self._Binaries == None:\r
self._Binaries = []\r
RecordList = self._RawData[MODEL_EFI_BINARY_FILE, self._Arch, self._Platform]\r
- Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource, 'PROCESSOR':self._Arch}\r
- Macros.update(self._Macros)\r
+ Macros = self._Macros\r
+ Macros["EDK_SOURCE"] = GlobalData.gEcpSource\r
+ Macros['PROCESSOR'] = self._Arch\r
for Record in RecordList:\r
- Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)\r
FileType = Record[0]\r
LineNo = Record[-1]\r
Target = 'COMMON'\r
if self._Sources == None:\r
self._Sources = []\r
RecordList = self._RawData[MODEL_EFI_SOURCE_FILE, self._Arch, self._Platform]\r
- Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource, 'PROCESSOR':self._Arch}\r
- Macros.update(self._Macros)\r
+ Macros = self._Macros\r
+ Macros["EDK_SOURCE"] = GlobalData.gEcpSource\r
+ Macros['PROCESSOR'] = self._Arch\r
for Record in RecordList:\r
- Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)\r
LineNo = Record[-1]\r
ToolChainFamily = Record[1]\r
TagName = Record[2]\r
ToolCode = Record[3]\r
FeatureFlag = Record[4]\r
- if self._AutoGenVersion < 0x00010005:\r
- # old module source files (EDK)\r
+ if self.AutoGenVersion < 0x00010005:\r
+ # old module source files (Edk)\r
File = PathClass(NormPath(Record[0], Macros), self._ModuleDir, self._SourceOverridePath,\r
'', False, self._Arch, ToolChainFamily, '', TagName, ToolCode)\r
# check the file validation\r
self._LibraryClasses = sdict()\r
RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch, self._Platform]\r
for Record in RecordList:\r
- Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)\r
Lib = Record[0]\r
Instance = Record[1]\r
- if Instance != None and Instance != '':\r
+ if Instance:\r
Instance = NormPath(Instance, self._Macros)\r
self._LibraryClasses[Lib] = Instance\r
return self._LibraryClasses\r
\r
- ## Retrieve library names (for EDK.x style of modules)\r
+ ## Retrieve library names (for Edk.x style of modules)\r
def _GetLibraryNames(self):\r
if self._Libraries == None:\r
self._Libraries = []\r
RecordList = self._RawData[MODEL_EFI_LIBRARY_INSTANCE, self._Arch, self._Platform]\r
for Record in RecordList:\r
- # in case of name with '.lib' extension, which is unusual in EDK.x inf\r
- Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)\r
- LibraryName = os.path.splitext(Record[0])[0]\r
+ LibraryName = ReplaceMacro(Record[0], self._Macros, False)\r
+ # in case of name with '.lib' extension, which is unusual in Edk.x inf\r
+ LibraryName = os.path.splitext(LibraryName)[0]\r
if LibraryName not in self._Libraries:\r
self._Libraries.append(LibraryName)\r
return self._Libraries\r
self._Guids[CName] = Value\r
return self._Guids\r
\r
- ## Retrieve include paths necessary for this module (for EDK.x style of modules)\r
+ ## Retrieve include paths necessary for this module (for Edk.x style of modules)\r
def _GetIncludes(self):\r
if self._Includes == None:\r
self._Includes = []\r
if self._SourceOverridePath:\r
self._Includes.append(self._SourceOverridePath)\r
+\r
+ Macros = self._Macros\r
+ if 'PROCESSOR' in GlobalData.gEdkGlobal.keys():\r
+ Macros['PROCESSOR'] = GlobalData.gEdkGlobal['PROCESSOR']\r
+ else:\r
+ Macros['PROCESSOR'] = self._Arch\r
RecordList = self._RawData[MODEL_EFI_INCLUDE, self._Arch, self._Platform]\r
- # [includes] section must be used only in old (EDK.x) inf file\r
- if self.AutoGenVersion >= 0x00010005 and len(RecordList) > 0:\r
- EdkLogger.error('build', FORMAT_NOT_SUPPORTED, "No [include] section allowed",\r
- File=self.MetaFile, Line=RecordList[0][-1]-1)\r
for Record in RecordList:\r
- Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)\r
- Record[0] = Record[0].replace('$(PROCESSOR)', self._Arch)\r
- Record[0] = ReplaceMacro(Record[0], {'EFI_SOURCE' : GlobalData.gEfiSource}, False)\r
if Record[0].find('EDK_SOURCE') > -1:\r
- File = NormPath(ReplaceMacro(Record[0], {'EDK_SOURCE' : GlobalData.gEcpSource}, False), self._Macros)\r
+ Macros['EDK_SOURCE'] = GlobalData.gEcpSource\r
+ File = NormPath(Record[0], self._Macros)\r
if File[0] == '.':\r
File = os.path.join(self._ModuleDir, File)\r
else:\r
self._Includes.append(File)\r
\r
#TRICK: let compiler to choose correct header file\r
- File = NormPath(ReplaceMacro(Record[0], {'EDK_SOURCE' : GlobalData.gEdkSource}, False), self._Macros)\r
+ Macros['EDK_SOURCE'] = GlobalData.gEdkSource\r
+ File = NormPath(Record[0], self._Macros)\r
if File[0] == '.':\r
File = os.path.join(self._ModuleDir, File)\r
else:\r
if File:\r
self._Includes.append(File)\r
else:\r
- File = NormPath(Record[0], self._Macros)\r
+ File = NormPath(Record[0], Macros)\r
if File[0] == '.':\r
File = os.path.join(self._ModuleDir, File)\r
else:\r
if self._Packages == None:\r
self._Packages = []\r
RecordList = self._RawData[MODEL_META_DATA_PACKAGE, self._Arch, self._Platform]\r
- Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource}\r
- Macros.update(self._Macros)\r
+ Macros = self._Macros\r
+ Macros['EDK_SOURCE'] = GlobalData.gEcpSource\r
for Record in RecordList:\r
File = PathClass(NormPath(Record[0], Macros), GlobalData.gWorkspace, Arch=self._Arch)\r
LineNo = Record[-1]\r
if ErrorCode != 0:\r
EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo)\r
# parse this package now. we need it to get protocol/ppi/guid value\r
- Package = self._Bdb[File, self._Arch]\r
+ Package = self._Bdb[File, self._Arch, self._Target, self._Toolchain]\r
self._Packages.append(Package)\r
return self._Packages\r
\r
self._BuildOptions[ToolChainFamily, ToolChain] = OptionString + " " + Option\r
return self._BuildOptions\r
\r
- ## Retrieve depedency expression\r
+ ## Retrieve dependency expression\r
def _GetDepex(self):\r
if self._Depex == None:\r
self._Depex = tdict(False, 2)\r
\r
# If the module has only Binaries and no Sources, then ignore [Depex] \r
if self.Sources == None or self.Sources == []:\r
- if self.Binaries <> None and self.Binaries <> []:\r
- return self._Depex\r
+ if self.Binaries != None and self.Binaries != []:\r
+ return self._Depex\r
\r
# PEIM and DXE drivers must have a valid [Depex] section\r
if len(self.LibraryClass) == 0 and len(RecordList) == 0:\r
EdkLogger.error('build', RESOURCE_NOT_AVAILABLE, "No [Depex] section or no valid expression in [Depex] section for [%s] module" \\r
% self.ModuleType, File=self.MetaFile)\r
\r
- Depex = {}\r
+ Depex = sdict()\r
for Record in RecordList:\r
- Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)\r
+ DepexStr = ReplaceMacro(Record[0], self._Macros, False)\r
Arch = Record[3]\r
ModuleType = Record[4]\r
- TokenList = Record[0].split()\r
+ TokenList = DepexStr.split()\r
if (Arch, ModuleType) not in Depex:\r
Depex[Arch, ModuleType] = []\r
DepexList = Depex[Arch, ModuleType]\r
if self._DepexExpression == None:\r
self._DepexExpression = tdict(False, 2)\r
RecordList = self._RawData[MODEL_EFI_DEPEX, self._Arch]\r
- DepexExpression = {}\r
+ DepexExpression = sdict()\r
for Record in RecordList:\r
- Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)\r
+ DepexStr = ReplaceMacro(Record[0], self._Macros, False)\r
Arch = Record[3]\r
ModuleType = Record[4]\r
- TokenList = Record[0].split()\r
+ TokenList = DepexStr.split()\r
if (Arch, ModuleType) not in DepexExpression:\r
DepexExpression[Arch, ModuleType] = ''\r
for Token in TokenList:\r
\r
return Pcds\r
\r
+ _Macros = property(_GetMacros)\r
Arch = property(_GetArch, _SetArch)\r
Platform = property(_GetPlatform, _SetPlatform)\r
\r
# @prarm RenewDb=False Create new database file if it's already there\r
#\r
class WorkspaceDatabase(object):\r
- # file parser\r
- _FILE_PARSER_ = {\r
- MODEL_FILE_INF : InfParser,\r
- MODEL_FILE_DEC : DecParser,\r
- MODEL_FILE_DSC : DscParser,\r
- MODEL_FILE_FDF : None, #FdfParser,\r
- MODEL_FILE_CIF : None\r
- }\r
-\r
- # file table\r
- _FILE_TABLE_ = {\r
- MODEL_FILE_INF : ModuleTable,\r
- MODEL_FILE_DEC : PackageTable,\r
- MODEL_FILE_DSC : PlatformTable,\r
- }\r
\r
# default database file path\r
_DB_PATH_ = "Conf/.cache/build.db"\r
# to avoid unnecessary re-parsing\r
#\r
class BuildObjectFactory(object):\r
+\r
_FILE_TYPE_ = {\r
".inf" : MODEL_FILE_INF,\r
".dec" : MODEL_FILE_DEC,\r
".dsc" : MODEL_FILE_DSC,\r
- ".fdf" : MODEL_FILE_FDF,\r
+ }\r
+\r
+ # file parser\r
+ _FILE_PARSER_ = {\r
+ MODEL_FILE_INF : InfParser,\r
+ MODEL_FILE_DEC : DecParser,\r
+ MODEL_FILE_DSC : DscParser,\r
}\r
\r
# convert to xxxBuildData object\r
MODEL_FILE_INF : InfBuildData,\r
MODEL_FILE_DEC : DecBuildData,\r
MODEL_FILE_DSC : DscBuildData,\r
- MODEL_FILE_FDF : None #FlashDefTable,\r
}\r
\r
_CACHE_ = {} # (FilePath, Arch) : <object>\r
def __init__(self, WorkspaceDb):\r
self.WorkspaceDb = WorkspaceDb\r
\r
- # key = (FilePath, Arch='COMMON')\r
+ # key = (FilePath, Arch=None)\r
def __contains__(self, Key):\r
FilePath = Key[0]\r
- Arch = 'COMMON'\r
if len(Key) > 1:\r
Arch = Key[1]\r
+ else:\r
+ Arch = None\r
return (FilePath, Arch) in self._CACHE_\r
\r
- # key = (FilePath, Arch='COMMON')\r
+ # key = (FilePath, Arch=None, Target=None, Toochain=None)\r
def __getitem__(self, Key):\r
FilePath = Key[0]\r
- Arch = 'COMMON'\r
- Platform = 'COMMON'\r
- if len(Key) > 1:\r
+ KeyLength = len(Key)\r
+ if KeyLength > 1:\r
Arch = Key[1]\r
- if len(Key) > 2:\r
- Platform = Key[2]\r
+ else:\r
+ Arch = None\r
+ if KeyLength > 2:\r
+ Target = Key[2]\r
+ else:\r
+ Target = None\r
+ if KeyLength > 3:\r
+ Toolchain = Key[3]\r
+ else:\r
+ Toolchain = None\r
\r
# if it's generated before, just return the cached one\r
- Key = (FilePath, Arch)\r
+ Key = (FilePath, Arch, Target, Toolchain)\r
if Key in self._CACHE_:\r
return self._CACHE_[Key]\r
\r
# check file type\r
- Ext = FilePath.Ext.lower()\r
+ Ext = FilePath.Type\r
if Ext not in self._FILE_TYPE_:\r
return None\r
FileType = self._FILE_TYPE_[Ext]\r
if FileType not in self._GENERATOR_:\r
return None\r
\r
- # get table for current file\r
- MetaFile = self.WorkspaceDb[FilePath, FileType, self.WorkspaceDb._GlobalMacros]\r
+ # get the parser ready for this file\r
+ MetaFile = self._FILE_PARSER_[FileType](\r
+ FilePath, \r
+ FileType, \r
+ MetaFileStorage(self.WorkspaceDb.Cur, FilePath, FileType)\r
+ )\r
+ # alwasy do post-process, in case of macros change\r
+ MetaFile.DoPostProcess()\r
+ # object the build is based on\r
BuildObject = self._GENERATOR_[FileType](\r
FilePath,\r
MetaFile,\r
self,\r
Arch,\r
- Platform,\r
- self.WorkspaceDb._GlobalMacros,\r
+ Target,\r
+ Toolchain\r
)\r
self._CACHE_[Key] = BuildObject\r
return BuildObject\r
# @param GlobalMacros Global macros used for replacement during file parsing\r
# @prarm RenewDb=False Create new database file if it's already there\r
#\r
- def __init__(self, DbPath, GlobalMacros={}, RenewDb=False):\r
+ def __init__(self, DbPath, RenewDb=False):\r
self._DbClosedFlag = False\r
- self._GlobalMacros = GlobalMacros\r
-\r
- if DbPath == None or DbPath == '':\r
+ if not DbPath:\r
DbPath = os.path.normpath(os.path.join(GlobalData.gWorkspace, self._DB_PATH_))\r
\r
# don't create necessary path for db in memory\r
# create table for internal uses\r
self.TblDataModel = TableDataModel(self.Cur)\r
self.TblFile = TableFile(self.Cur)\r
+ self.Platform = None\r
\r
# conversion object for build or file format conversion purpose\r
self.BuildObject = WorkspaceDatabase.BuildObjectFactory(self)\r
# @return Bool value for whether need renew workspace databse\r
#\r
def _CheckWhetherDbNeedRenew (self, force, DbPath):\r
- DbDir = os.path.split(DbPath)[0]\r
- MacroFilePath = os.path.normpath(os.path.join(DbDir, "build.mac"))\r
- MacroMatch = False\r
- if os.path.exists(MacroFilePath) and os.path.isfile(MacroFilePath):\r
- LastMacros = None\r
- try:\r
- f = open(MacroFilePath,'r')\r
- LastMacros = pickle.load(f)\r
- f.close()\r
- except IOError:\r
- pass\r
- except:\r
- f.close()\r
-\r
- if LastMacros != None and type(LastMacros) is DictType:\r
- if LastMacros == self._GlobalMacros:\r
- MacroMatch = True\r
- for Macro in LastMacros.keys():\r
- if not (Macro in self._GlobalMacros and LastMacros[Macro] == self._GlobalMacros[Macro]):\r
- MacroMatch = False;\r
- break;\r
-\r
- if not MacroMatch:\r
- # save command line macros to file\r
- try:\r
- f = open(MacroFilePath,'w')\r
- pickle.dump(self._GlobalMacros, f, 2)\r
- f.close()\r
- except IOError:\r
- pass\r
- except:\r
- f.close()\r
-\r
- force = True\r
-\r
# if database does not exist, we need do nothing\r
if not os.path.exists(DbPath): return False\r
\r
def QueryTable(self, Table):\r
Table.Query()\r
\r
+ def __del__(self):\r
+ self.Close()\r
+\r
## Close entire database\r
#\r
# Commit all first\r
self.Conn.close()\r
self._DbClosedFlag = True\r
\r
- ## Get unique file ID for the gvien file\r
- def GetFileId(self, FilePath):\r
- return self.TblFile.GetFileId(FilePath)\r
-\r
- ## Get file type value for the gvien file ID\r
- def GetFileType(self, FileId):\r
- return self.TblFile.GetFileType(FileId)\r
-\r
- ## Get time stamp stored in file table\r
- def GetTimeStamp(self, FileId):\r
- return self.TblFile.GetFileTimeStamp(FileId)\r
-\r
- ## Update time stamp in file table\r
- def SetTimeStamp(self, FileId, TimeStamp):\r
- return self.TblFile.SetFileTimeStamp(FileId, TimeStamp)\r
-\r
- ## Check if a table integrity flag exists or not\r
- def CheckIntegrity(self, TableName):\r
- try:\r
- Result = self.Cur.execute("select min(ID) from %s" % (TableName)).fetchall()\r
- if Result[0][0] != -1:\r
- return False\r
- #\r
- # Check whether the meta data file has external dependency by comparing the time stamp\r
- #\r
- Sql = "select Value1, Value2 from %s where Model=%d" % (TableName, MODEL_EXTERNAL_DEPENDENCY)\r
- for Dependency in self.Cur.execute(Sql).fetchall():\r
- if str(os.stat(Dependency[0])[8]) != Dependency[1]:\r
- return False\r
- except:\r
- return False\r
- return True\r
-\r
- ## Compose table name for given file type and file ID\r
- def GetTableName(self, FileType, FileId):\r
- return "_%s_%s" % (FileType, FileId)\r
-\r
- ## Return a temp table containing all content of the given file\r
- #\r
- # @param FileInfo The tuple containing path and type of a file\r
- #\r
- def __getitem__(self, FileInfo):\r
- FilePath, FileType, Macros = FileInfo\r
- if FileType not in self._FILE_TABLE_:\r
- return None\r
-\r
- # flag used to indicate if it's parsed or not\r
- FilePath = str(FilePath)\r
- Parsed = False\r
- FileId = self.GetFileId(FilePath)\r
- if FileId != None:\r
- TimeStamp = os.stat(FilePath)[8]\r
- TableName = self.GetTableName(FileType, FileId)\r
- if TimeStamp != self.GetTimeStamp(FileId):\r
- # update the timestamp in database\r
- self.SetTimeStamp(FileId, TimeStamp)\r
- else:\r
- # if the table exists and is integrity, don't parse it\r
- Parsed = self.CheckIntegrity(TableName)\r
- else:\r
- FileId = self.TblFile.InsertFile(FilePath, FileType)\r
- TableName = self.GetTableName(FileType, FileId)\r
-\r
- FileTable = self._FILE_TABLE_[FileType](self.Cur, TableName, FileId)\r
- FileTable.Create(not Parsed)\r
- Parser = self._FILE_PARSER_[FileType](FilePath, FileType, FileTable, Macros)\r
- # set the "Finished" flag in parser in order to avoid re-parsing (if parsed)\r
- Parser.Finished = Parsed\r
- return Parser\r
-\r
## Summarize all packages in the database\r
- def _GetPackageList(self):\r
- PackageList = []\r
- for Module in self.ModuleList:\r
- for Package in Module.Packages:\r
+ def GetPackageList(self, Platform, Arch, TargetName, ToolChainTag):\r
+ self.Platform = Platform\r
+ PackageList =[]\r
+ Pa = self.BuildObject[self.Platform, 'COMMON']\r
+ #\r
+ # Get Package related to Modules\r
+ #\r
+ for Module in Pa.Modules:\r
+ ModuleObj = self.BuildObject[Module, Arch, TargetName, ToolChainTag]\r
+ for Package in ModuleObj.Packages:\r
if Package not in PackageList:\r
PackageList.append(Package)\r
+ #\r
+ # Get Packages related to Libraries\r
+ #\r
+ for Lib in Pa.LibraryInstances:\r
+ LibObj = self.BuildObject[Lib, Arch, TargetName, ToolChainTag]\r
+ for Package in LibObj.Packages:\r
+ if Package not in PackageList:\r
+ PackageList.append(Package) \r
+ \r
return PackageList\r
\r
## Summarize all platforms in the database\r
PlatformList.append(Platform)\r
return PlatformList\r
\r
- ## Summarize all modules in the database\r
- def _GetModuleList(self):\r
- ModuleList = []\r
- for ModuleFile in self.TblFile.GetFileList(MODEL_FILE_INF):\r
- try:\r
- Module = self.BuildObject[PathClass(ModuleFile), 'COMMON']\r
- except:\r
- Module = None\r
- if Module != None:\r
- ModuleList.append(Module)\r
- return ModuleList\r
-\r
PlatformList = property(_GetPlatformList)\r
- PackageList = property(_GetPackageList)\r
- ModuleList = property(_GetModuleList)\r
\r
##\r
#\r
projects / mirror_edk2.git / blobdiff