diff options
Diffstat (limited to 'BaseTools/Source/Python/Common/InfClassObjectLight.py')
| -rw-r--r-- | BaseTools/Source/Python/Common/InfClassObjectLight.py | 876 |
1 files changed, 876 insertions, 0 deletions
diff --git a/BaseTools/Source/Python/Common/InfClassObjectLight.py b/BaseTools/Source/Python/Common/InfClassObjectLight.py new file mode 100644 index 0000000000..a655828e6a --- /dev/null +++ b/BaseTools/Source/Python/Common/InfClassObjectLight.py @@ -0,0 +1,876 @@ +## @file
+# This file is used to define each component of INF file
+#
+# Copyright (c) 2007, Intel Corporation
+# All rights reserved. This program and the accompanying materials
+# are licensed and made available under the terms and conditions of the BSD License
+# which accompanies this distribution. The full text of the license may be found at
+# http://opensource.org/licenses/bsd-license.php
+#
+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+#
+
+##
+# Import Modules
+#
+import os
+import re
+import EdkLogger
+
+from CommonDataClass.ModuleClass import *
+from CommonDataClass import CommonClass
+from String import *
+from DataType import *
+from BuildToolError import *
+from Misc import sdict
+from Misc import GetFiles
+from Parsing import *
+
+# Global variable
+Section = {TAB_UNKNOWN.upper() : MODEL_UNKNOWN,
+ TAB_INF_DEFINES.upper() : MODEL_META_DATA_HEADER,
+ TAB_BUILD_OPTIONS.upper() : MODEL_META_DATA_BUILD_OPTION,
+ TAB_INCLUDES.upper() : MODEL_EFI_INCLUDE,
+ TAB_LIBRARIES.upper() : MODEL_EFI_LIBRARY_INSTANCE,
+ TAB_LIBRARY_CLASSES.upper() : MODEL_EFI_LIBRARY_CLASS,
+ TAB_PACKAGES.upper() : MODEL_META_DATA_PACKAGE,
+ TAB_NMAKE.upper() : MODEL_META_DATA_NMAKE,
+ TAB_INF_FIXED_PCD.upper() : MODEL_PCD_FIXED_AT_BUILD,
+ TAB_INF_PATCH_PCD.upper() : MODEL_PCD_PATCHABLE_IN_MODULE,
+ TAB_INF_FEATURE_PCD.upper() : MODEL_PCD_FEATURE_FLAG,
+ TAB_INF_PCD_EX.upper() : MODEL_PCD_DYNAMIC_EX,
+ TAB_INF_PCD.upper() : MODEL_PCD_DYNAMIC,
+ TAB_SOURCES.upper() : MODEL_EFI_SOURCE_FILE,
+ TAB_GUIDS.upper() : MODEL_EFI_GUID,
+ TAB_PROTOCOLS.upper() : MODEL_EFI_PROTOCOL,
+ TAB_PPIS.upper() : MODEL_EFI_PPI,
+ TAB_DEPEX.upper() : MODEL_EFI_DEPEX,
+ TAB_BINARIES.upper() : MODEL_EFI_BINARY_FILE,
+ TAB_USER_EXTENSIONS.upper() : MODEL_META_DATA_USER_EXTENSION
+ }
+
+gComponentType2ModuleType = {
+ "LIBRARY" : "BASE",
+ "SECURITY_CORE" : "SEC",
+ "PEI_CORE" : "PEI_CORE",
+ "COMBINED_PEIM_DRIVER" : "PEIM",
+ "PIC_PEIM" : "PEIM",
+ "RELOCATABLE_PEIM" : "PEIM",
+ "PE32_PEIM" : "PEIM",
+ "BS_DRIVER" : "DXE_DRIVER",
+ "RT_DRIVER" : "DXE_RUNTIME_DRIVER",
+ "SAL_RT_DRIVER" : "DXE_SAL_DRIVER",
+ "APPLICATION" : "UEFI_APPLICATION",
+ "LOGO" : "BASE",
+}
+
+class InfHeader(ModuleHeaderClass):
+ _Mapping_ = {
+ # Required Fields
+ TAB_INF_DEFINES_BASE_NAME : "Name",
+ TAB_INF_DEFINES_FILE_GUID : "Guid",
+ TAB_INF_DEFINES_MODULE_TYPE : "ModuleType",
+ TAB_INF_DEFINES_EFI_SPECIFICATION_VERSION : "EfiSpecificationVersion",
+ TAB_INF_DEFINES_EDK_RELEASE_VERSION : "EdkReleaseVersion",
+
+ # Optional Fields
+ TAB_INF_DEFINES_INF_VERSION : "InfVersion",
+ TAB_INF_DEFINES_BINARY_MODULE : "BinaryModule",
+ TAB_INF_DEFINES_COMPONENT_TYPE : "ComponentType",
+ TAB_INF_DEFINES_MAKEFILE_NAME : "MakefileName",
+ TAB_INF_DEFINES_BUILD_NUMBER : "BuildNumber",
+ TAB_INF_DEFINES_BUILD_TYPE : "BuildType",
+ TAB_INF_DEFINES_FFS_EXT : "FfsExt",
+ TAB_INF_DEFINES_FV_EXT : "FvExt",
+ TAB_INF_DEFINES_SOURCE_FV : "SourceFv",
+ TAB_INF_DEFINES_VERSION_NUMBER : "VersionNumber",
+ TAB_INF_DEFINES_VERSION_STRING : "VersionString",
+ TAB_INF_DEFINES_VERSION : "Version",
+ TAB_INF_DEFINES_PCD_IS_DRIVER : "PcdIsDriver",
+ TAB_INF_DEFINES_TIANO_R8_FLASHMAP_H : "TianoR8FlashMap_h",
+ TAB_INF_DEFINES_SHADOW : "Shadow",
+ }
+
+ def __init__(self):
+ ModuleHeaderClass.__init__(self)
+ self.VersionNumber = ''
+ self.VersionString = ''
+ #print self.__dict__
+ def __setitem__(self, key, value):
+ self.__dict__[self._Mapping_[key]] = value
+ def __getitem__(self, key):
+ return self.__dict__[self._Mapping_[key]]
+ ## "in" test support
+ def __contains__(self, key):
+ return key in self._Mapping_
+
+## InfObject
+#
+# This class defined basic Inf object which is used by inheriting
+#
+# @param object: Inherited from object class
+#
+class InfObject(object):
+ def __init__(self):
+ object.__init__()
+
+## Inf
+#
+# This class defined the structure used in Inf object
+#
+# @param InfObject: Inherited from InfObject class
+# @param Ffilename: Input value for Ffilename of Inf file, default is None
+# @param IsMergeAllArches: Input value for IsMergeAllArches
+# True is to merge all arches
+# Fales is not to merge all arches
+# default is False
+# @param IsToModule: Input value for IsToModule
+# True is to transfer to ModuleObject automatically
+# False is not to transfer to ModuleObject automatically
+# default is False
+# @param WorkspaceDir: Input value for current workspace directory, default is None
+#
+# @var Identification: To store value for Identification, it is a structure as Identification
+# @var UserExtensions: To store value for UserExtensions
+# @var Module: To store value for Module, it is a structure as ModuleClass
+# @var WorkspaceDir: To store value for WorkspaceDir
+# @var KeyList: To store value for KeyList, a list for all Keys used in Inf
+#
+class Inf(InfObject):
+ def __init__(self, Filename = None, IsToModule = False, WorkspaceDir = None, PackageDir = None, SupArchList = DataType.ARCH_LIST):
+ self.Identification = IdentificationClass()
+ self.Module = ModuleClass()
+ self.WorkspaceDir = WorkspaceDir
+ self.PackageDir = PackageDir
+ self.SupArchList = SupArchList
+
+ self.KeyList = [
+ TAB_SOURCES, TAB_BUILD_OPTIONS, TAB_BINARIES, TAB_INCLUDES, TAB_GUIDS,
+ TAB_PROTOCOLS, TAB_PPIS, TAB_LIBRARY_CLASSES, TAB_PACKAGES, TAB_INF_FIXED_PCD,
+ TAB_INF_PATCH_PCD, TAB_INF_FEATURE_PCD, TAB_INF_PCD, TAB_INF_PCD_EX,
+ TAB_DEPEX, TAB_INF_DEFINES
+ ]
+ # Upper all KEYs to ignore case sensitive when parsing
+ self.KeyList = map(lambda c: c.upper(), self.KeyList)
+
+ # Init RecordSet
+ self.RecordSet = {}
+ for Key in self.KeyList:
+ self.RecordSet[Section[Key]] = []
+
+ # Init Comment
+ self.SectionHeaderCommentDict = {}
+
+ # Load Inf file if filename is not None
+ if Filename != None:
+ self.LoadInfFile(Filename)
+
+ # Transfer to Module Object if IsToModule is True
+ if IsToModule:
+ self.InfToModule()
+
+ ## Module Object to INF file
+ def ModuleToInf(self, Module):
+ Inf = ''
+ InfList = sdict()
+ SectionHeaderCommentDict = {}
+ if Module == None:
+ return Inf
+
+ ModuleHeader = Module.ModuleHeader
+ TmpList = []
+ # Common define items
+ if ModuleHeader.Name:
+ TmpList.append(TAB_INF_DEFINES_BASE_NAME + ' = ' + ModuleHeader.Name)
+ if ModuleHeader.Guid:
+ TmpList.append(TAB_INF_DEFINES_FILE_GUID + ' = ' + ModuleHeader.Guid)
+ if ModuleHeader.Version:
+ TmpList.append(TAB_INF_DEFINES_VERSION_STRING + ' = ' + ModuleHeader.Version)
+ if ModuleHeader.ModuleType:
+ TmpList.append(TAB_INF_DEFINES_MODULE_TYPE + ' = ' + ModuleHeader.ModuleType)
+ if ModuleHeader.PcdIsDriver:
+ TmpList.append(TAB_INF_DEFINES_PCD_IS_DRIVER + ' = ' + ModuleHeader.PcdIsDriver)
+ # Externs
+ for Item in Module.Externs:
+ if Item.EntryPoint:
+ TmpList.append(TAB_INF_DEFINES_ENTRY_POINT + ' = ' + Item.EntryPoint)
+ if Item.UnloadImage:
+ TmpList.append(TAB_INF_DEFINES_UNLOAD_IMAGE + ' = ' + Item.UnloadImage)
+ if Item.Constructor:
+ TmpList.append(TAB_INF_DEFINES_CONSTRUCTOR + ' = ' + Item.Constructor)
+ if Item.Destructor:
+ TmpList.append(TAB_INF_DEFINES_DESTRUCTOR + ' = ' + Item.Destructor)
+ # Other define items
+ if Module.UserExtensions != None:
+ for Item in Module.UserExtensions.Defines:
+ TmpList.append(Item)
+ InfList['Defines'] = TmpList
+ if ModuleHeader.Description != '':
+ SectionHeaderCommentDict['Defines'] = ModuleHeader.Description
+
+ if Module.UserExtensions != None:
+ InfList['BuildOptions'] = Module.UserExtensions.BuildOptions
+
+ for Item in Module.Includes:
+ Key = 'Includes.' + GetStringOfList(Item.SupArchList)
+ Value = GetHelpTextList(Item.HelpTextList)
+ Value.append(Item.FilePath)
+ GenMetaDatSectionItem(Key, Value, InfList)
+
+ for Item in Module.LibraryClasses:
+ Key = 'LibraryClasses.' + GetStringOfList(Item.SupArchList)
+ Value = GetHelpTextList(Item.HelpTextList)
+ NewValue = Item.LibraryClass
+ if Item.RecommendedInstance:
+ NewValue = NewValue + '|' + Item.RecommendedInstance
+ if Item.FeatureFlag:
+ NewValue = NewValue + '|' + Item.FeatureFlag
+ Value.append(NewValue)
+ GenMetaDatSectionItem(Key, Value, InfList)
+
+ for Item in Module.PackageDependencies:
+ Key = 'Packages.' + GetStringOfList(Item.SupArchList)
+ Value = GetHelpTextList(Item.HelpTextList)
+ Value.append(Item.FilePath)
+ GenMetaDatSectionItem(Key, Value, InfList)
+
+ for Item in Module.PcdCodes:
+ Key = 'Pcds' + Item.ItemType + '.' + GetStringOfList(Item.SupArchList)
+ Value = GetHelpTextList(Item.HelpTextList)
+ NewValue = Item.TokenSpaceGuidCName + '.' + Item.CName
+ if Item.DefaultValue != '':
+ NewValue = NewValue + '|' + Item.DefaultValue
+ Value.append(NewValue)
+ GenMetaDatSectionItem(Key, Value, InfList)
+
+ for Item in Module.Sources:
+ Key = 'Sources.' + GetStringOfList(Item.SupArchList)
+ Value = GetHelpTextList(Item.HelpTextList)
+ NewValue = Item.SourceFile
+ if Item.ToolChainFamily != '':
+ NewValue = NewValue + '|' + Item.ToolChainFamily
+ if Item.TagName != '':
+ NewValue = NewValue + '|' + Item.TagName
+ if Item.ToolCode != '':
+ NewValue = NewValue + '|' + Item.ToolCode
+ if Item.FeatureFlag != '':
+ NewValue = NewValue + '|' + Item.FeatureFlag
+ Value.append(NewValue)
+ if Item.HelpText != '':
+ SectionHeaderCommentDict[Key] = Item.HelpText
+ GenMetaDatSectionItem(Key, Value, InfList)
+
+ for Item in Module.Guids:
+ Key = 'Guids.' + GetStringOfList(Item.SupArchList)
+ Value = GetHelpTextList(Item.HelpTextList)
+ Value.append(Item.CName)
+ GenMetaDatSectionItem(Key, Value, InfList)
+
+ for Item in Module.Protocols:
+ Key = 'Protocols.' + GetStringOfList(Item.SupArchList)
+ Value = GetHelpTextList(Item.HelpTextList)
+ Value.append(Item.CName)
+ GenMetaDatSectionItem(Key, Value, InfList)
+
+ for Item in Module.Ppis:
+ Key = 'Ppis.' + GetStringOfList(Item.SupArchList)
+ Value = GetHelpTextList(Item.HelpTextList)
+ Value.append(Item.CName)
+ GenMetaDatSectionItem(Key, Value, InfList)
+
+ if Module.PeiDepex:
+ Key = 'Depex'
+ Value = Module.PeiDepex.Depex
+ GenMetaDatSectionItem(Key, Value, InfList)
+
+ if Module.DxeDepex:
+ Key = 'Depex'
+ Value = Module.DxeDepex.Depex
+ GenMetaDatSectionItem(Key, Value, InfList)
+
+ if Module.SmmDepex:
+ Key = 'Depex'
+ Value = Module.SmmDepex.Depex
+ GenMetaDatSectionItem(Key, Value, InfList)
+
+ for Item in Module.Binaries:
+ Key = 'Binaries.' + GetStringOfList(Item.SupArchList)
+ Value = GetHelpTextList(Item.HelpTextList)
+ NewValue = Item.FileType + '|' + Item.BinaryFile + '|' + Item.Target
+ if Item.FeatureFlag != '':
+ NewValue = NewValue + '|' + Item.FeatureFlag
+ Value.append(NewValue)
+ GenMetaDatSectionItem(Key, Value, InfList)
+
+ # Transfer Module to Inf
+ for Key in InfList:
+ if Key in SectionHeaderCommentDict:
+ List = SectionHeaderCommentDict[Key].split('\r')
+ for Item in List:
+ Inf = Inf + Item + '\n'
+ Inf = Inf + '[' + Key + ']' + '\n'
+ for Value in InfList[Key]:
+ if type(Value) == type([]):
+ for SubValue in Value:
+ Inf = Inf + ' ' + SubValue + '\n'
+ else:
+ Inf = Inf + ' ' + Value + '\n'
+ Inf = Inf + '\n'
+
+ return Inf
+
+
+ ## Transfer to Module Object
+ #
+ # Transfer all contents of an Inf file to a standard Module Object
+ #
+ def InfToModule(self):
+ # Init global information for the file
+ ContainerFile = self.Identification.FullPath
+
+ # Generate Module Header
+ self.GenModuleHeader(ContainerFile)
+
+ # Generate BuildOptions
+ self.GenBuildOptions(ContainerFile)
+
+ # Generate Includes
+ self.GenIncludes(ContainerFile)
+
+ # Generate LibraryClasses
+ self.GenLibraryClasses(ContainerFile)
+
+ # Generate Packages
+ self.GenPackages(ContainerFile)
+
+ # Generate Pcds
+ self.GenPcds(ContainerFile)
+
+ # Generate Sources
+ self.GenSources(ContainerFile)
+
+ # Generate Guids
+ self.GenGuidProtocolPpis(DataType.TAB_GUIDS, ContainerFile)
+
+ # Generate Protocols
+ self.GenGuidProtocolPpis(DataType.TAB_PROTOCOLS, ContainerFile)
+
+ # Generate Ppis
+ self.GenGuidProtocolPpis(DataType.TAB_PPIS, ContainerFile)
+
+ # Generate Depexes
+ self.GenDepexes(ContainerFile)
+
+ # Generate Binaries
+ self.GenBinaries(ContainerFile)
+
+ # Init MiscFiles
+ self.GenMiscFiles(ContainerFile)
+
+ ## GenMiscFiles
+ #
+ def GenMiscFiles(self, ContainerFile):
+ MiscFiles = MiscFileClass()
+ MiscFiles.Name = 'ModuleFiles'
+ for Item in GetFiles(os.path.dirname(ContainerFile), ['CVS', '.svn'], False):
+ File = CommonClass.FileClass()
+ File.Filename = Item
+ MiscFiles.Files.append(File)
+ self.Module.MiscFiles = MiscFiles
+
+ ## Load Inf file
+ #
+ # Load the file if it exists
+ #
+ # @param Filename: Input value for filename of Inf file
+ #
+ def LoadInfFile(self, Filename):
+ # Insert a record for file
+ Filename = NormPath(Filename)
+
+ self.Identification.FullPath = Filename
+ (self.Identification.RelaPath, self.Identification.FileName) = os.path.split(Filename)
+ if self.Identification.FullPath.find(self.WorkspaceDir) > -1:
+ self.Identification.ModulePath = os.path.dirname(self.Identification.FullPath[len(self.WorkspaceDir) + 1:])
+ if self.PackageDir:
+ self.Identification.PackagePath = self.PackageDir
+ if self.Identification.ModulePath.find(self.PackageDir) == 0:
+ self.Identification.ModulePath = self.Identification.ModulePath[len(self.PackageDir) + 1:]
+
+ # Init common datas
+ IfDefList, SectionItemList, CurrentSection, ArchList, ThirdList, IncludeFiles = \
+ [], [], TAB_UNKNOWN, [], [], []
+ LineNo = 0
+
+ # Parse file content
+ IsFindBlockComment = False
+ ReservedLine = ''
+ Comment = ''
+ for Line in open(Filename, 'r'):
+ LineNo = LineNo + 1
+ # Remove comment block
+ if Line.find(TAB_COMMENT_R8_START) > -1:
+ ReservedLine = GetSplitValueList(Line, TAB_COMMENT_R8_START, 1)[0]
+ if ReservedLine.strip().startswith(TAB_COMMENT_SPLIT):
+ Comment = Comment + Line.strip() + '\n'
+ ReservedLine = ''
+ else:
+ Comment = Comment + Line[len(ReservedLine):] + '\n'
+ IsFindBlockComment = True
+ if not ReservedLine:
+ continue
+ if Line.find(TAB_COMMENT_R8_END) > -1:
+ Comment = Comment + Line[:Line.find(TAB_COMMENT_R8_END) + len(TAB_COMMENT_R8_END)] + '\n'
+ Line = ReservedLine + GetSplitValueList(Line, TAB_COMMENT_R8_END, 1)[1]
+ ReservedLine = ''
+ IsFindBlockComment = False
+ if IsFindBlockComment:
+ Comment = Comment + Line.strip() + '\n'
+ continue
+
+ # Remove comments at tail and remove spaces again
+ if Line.strip().startswith(TAB_COMMENT_SPLIT) or Line.strip().startswith('--/'):
+ Comment = Comment + Line.strip() + '\n'
+ Line = CleanString(Line)
+ if Line == '':
+ continue
+
+ ## Find a new section tab
+ # First insert previous section items
+ # And then parse the content of the new section
+ if Line.startswith(TAB_SECTION_START) and Line.endswith(TAB_SECTION_END):
+ if Line[1:3] == "--":
+ continue
+ Model = Section[CurrentSection.upper()]
+ # Insert items data of previous section
+ InsertSectionItems(Model, CurrentSection, SectionItemList, ArchList, ThirdList, self.RecordSet)
+
+ # Parse the new section
+ SectionItemList = []
+ ArchList = []
+ ThirdList = []
+
+ CurrentSection = ''
+ LineList = GetSplitValueList(Line[len(TAB_SECTION_START):len(Line) - len(TAB_SECTION_END)], TAB_COMMA_SPLIT)
+ for Item in LineList:
+ ItemList = GetSplitValueList(Item, TAB_SPLIT)
+ if CurrentSection == '':
+ CurrentSection = ItemList[0]
+ else:
+ if CurrentSection != ItemList[0]:
+ EdkLogger.error("Parser", PARSER_ERROR, "Different section names '%s' and '%s' are found in one section definition, this is not allowed." % (CurrentSection, ItemList[0]), File=Filename, Line=LineNo, RaiseError = EdkLogger.IsRaiseError)
+ if CurrentSection.upper() not in self.KeyList:
+ RaiseParserError(Line, CurrentSection, Filename, '', LineNo)
+ ItemList.append('')
+ ItemList.append('')
+ if len(ItemList) > 5:
+ RaiseParserError(Line, CurrentSection, Filename, '', LineNo)
+ else:
+ if ItemList[1] != '' and ItemList[1].upper() not in ARCH_LIST_FULL:
+ EdkLogger.error("Parser", PARSER_ERROR, "Invalid Arch definition '%s' found" % ItemList[1], File=Filename, Line=LineNo, RaiseError = EdkLogger.IsRaiseError)
+ ArchList.append(ItemList[1].upper())
+ ThirdList.append(ItemList[2])
+
+ if Comment:
+ if Comment.endswith('\n'):
+ Comment = Comment[:len(Comment) - len('\n')]
+ self.SectionHeaderCommentDict[Section[CurrentSection.upper()]] = Comment
+ Comment = ''
+ continue
+
+ # Not in any defined section
+ if CurrentSection == TAB_UNKNOWN:
+ ErrorMsg = "%s is not in any defined section" % Line
+ EdkLogger.error("Parser", PARSER_ERROR, ErrorMsg, File=Filename, Line=LineNo, RaiseError = EdkLogger.IsRaiseError)
+
+ # Add a section item
+ SectionItemList.append([Line, LineNo, Comment])
+ Comment = ''
+ # End of parse
+ #End of For
+
+ # Insert items data of last section
+ Model = Section[CurrentSection.upper()]
+ InsertSectionItems(Model, CurrentSection, SectionItemList, ArchList, ThirdList, self.RecordSet)
+ if Comment != '':
+ self.SectionHeaderCommentDict[Model] = Comment
+ Comment = ''
+
+ ## Show detailed information of Module
+ #
+ # Print all members and their values of Module class
+ #
+ def ShowModule(self):
+ M = self.Module
+ print 'Filename =', M.ModuleHeader.FileName
+ print 'FullPath =', M.ModuleHeader.FullPath
+ print 'RelaPath =', M.ModuleHeader.RelaPath
+ print 'PackagePath =', M.ModuleHeader.PackagePath
+ print 'ModulePath =', M.ModuleHeader.ModulePath
+ print 'CombinePath =', M.ModuleHeader.CombinePath
+
+ print 'BaseName =', M.ModuleHeader.Name
+ print 'Guid =', M.ModuleHeader.Guid
+ print 'Version =', M.ModuleHeader.Version
+
+ print '\nIncludes ='
+ for Item in M.Includes:
+ print Item.FilePath, Item.SupArchList
+ print '\nLibraryClasses ='
+ for Item in M.LibraryClasses:
+ print Item.LibraryClass, Item.RecommendedInstance, Item.RecommendedInstanceGuid, Item.RecommendedInstanceVersion, Item.FeatureFlag, Item.SupModuleList, Item.SupArchList, Item.Define
+ print '\nPackageDependencies ='
+ for Item in M.PackageDependencies:
+ print Item.FilePath, Item.SupArchList, Item.FeatureFlag
+ print '\nPcds ='
+ for Item in M.PcdCodes:
+ print '\tCName=',Item.CName, 'TokenSpaceGuidCName=', Item.TokenSpaceGuidCName, 'DefaultValue=', Item.DefaultValue, 'ItemType=', Item.ItemType, Item.SupArchList
+ print '\nSources ='
+ for Source in M.Sources:
+ print Source.SourceFile, 'Fam=', Source.ToolChainFamily, 'Pcd=', Source.FeatureFlag, 'Tag=', Source.TagName, 'ToolCode=', Source.ToolCode, Source.SupArchList
+ print '\nGuids ='
+ for Item in M.Guids:
+ print Item.CName, Item.SupArchList, Item.FeatureFlag
+ print '\nProtocols ='
+ for Item in M.Protocols:
+ print Item.CName, Item.SupArchList, Item.FeatureFlag
+ print '\nPpis ='
+ for Item in M.Ppis:
+ print Item.CName, Item.SupArchList, Item.FeatureFlag
+ print '\nDepex ='
+ for Item in M.Depex:
+ print Item.Depex, Item.SupArchList, Item.Define
+ print '\nBinaries ='
+ for Binary in M.Binaries:
+ print 'Type=', Binary.FileType, 'Target=', Binary.Target, 'Name=', Binary.BinaryFile, 'FeatureFlag=', Binary.FeatureFlag, 'SupArchList=', Binary.SupArchList
+ print '\n*** FileList ***'
+ for Item in M.MiscFiles.Files:
+ print Item.Filename
+ print '****************\n'
+
+ ## Convert [Defines] section content to ModuleHeaderClass
+ #
+ # Convert [Defines] section content to ModuleHeaderClass
+ #
+ # @param Defines The content under [Defines] section
+ # @param ModuleHeader An object of ModuleHeaderClass
+ # @param Arch The supported ARCH
+ #
+ def GenModuleHeader(self, ContainerFile):
+ EdkLogger.debug(2, "Generate ModuleHeader ...")
+ # Update all defines item in database
+ RecordSet = self.RecordSet[MODEL_META_DATA_HEADER]
+
+ ModuleHeader = ModuleHeaderClass()
+ ModuleExtern = ModuleExternClass()
+ OtherDefines = []
+ for Record in RecordSet:
+ ValueList = GetSplitValueList(Record[0], TAB_EQUAL_SPLIT)
+ if len(ValueList) != 2:
+ OtherDefines.append(Record[0])
+ else:
+ Name = ValueList[0]
+ Value = ValueList[1]
+ if Name == TAB_INF_DEFINES_BASE_NAME:
+ ModuleHeader.Name = Value
+ ModuleHeader.BaseName = Value
+ elif Name == TAB_INF_DEFINES_FILE_GUID:
+ ModuleHeader.Guid = Value
+ elif Name == TAB_INF_DEFINES_VERSION_STRING:
+ ModuleHeader.Version = Value
+ elif Name == TAB_INF_DEFINES_PCD_IS_DRIVER:
+ ModuleHeader.PcdIsDriver = Value
+ elif Name == TAB_INF_DEFINES_MODULE_TYPE:
+ ModuleHeader.ModuleType = Value
+ elif Name == TAB_INF_DEFINES_UEFI_SPECIFICATION_VERSION:
+ ModuleHeader.UefiSpecificationVersion = Value
+ elif Name == TAB_INF_DEFINES_PI_SPECIFICATION_VERSION:
+ ModuleHeader.PiSpecificationVersion = Value
+ elif Name == TAB_INF_DEFINES_ENTRY_POINT:
+ ModuleExtern.EntryPoint = Value
+ elif Name == TAB_INF_DEFINES_UNLOAD_IMAGE:
+ ModuleExtern.UnloadImage = Value
+ elif Name == TAB_INF_DEFINES_CONSTRUCTOR:
+ ModuleExtern.Constructor = Value
+ elif Name == TAB_INF_DEFINES_DESTRUCTOR:
+ ModuleExtern.Destructor = Value
+ else:
+ OtherDefines.append(Record[0])
+ ModuleHeader.FileName = self.Identification.FileName
+ ModuleHeader.FullPath = self.Identification.FullPath
+ ModuleHeader.RelaPath = self.Identification.RelaPath
+ ModuleHeader.PackagePath = self.Identification.PackagePath
+ ModuleHeader.ModulePath = self.Identification.ModulePath
+ ModuleHeader.CombinePath = os.path.normpath(os.path.join(ModuleHeader.PackagePath, ModuleHeader.ModulePath, ModuleHeader.FileName))
+
+ if MODEL_META_DATA_HEADER in self.SectionHeaderCommentDict:
+ ModuleHeader.Description = self.SectionHeaderCommentDict[MODEL_META_DATA_HEADER]
+ self.Module.ModuleHeader = ModuleHeader
+ self.Module.Externs.append(ModuleExtern)
+ UE = self.Module.UserExtensions
+ if UE == None:
+ UE = UserExtensionsClass()
+ UE.Defines = OtherDefines
+ self.Module.UserExtensions = UE
+
+ ## GenBuildOptions
+ #
+ # Gen BuildOptions of Inf
+ # [<Family>:]<ToolFlag>=Flag
+ #
+ # @param ContainerFile: The Inf file full path
+ #
+ def GenBuildOptions(self, ContainerFile):
+ EdkLogger.debug(2, "Generate %s ..." % TAB_BUILD_OPTIONS)
+ BuildOptions = {}
+ # Get all BuildOptions
+ RecordSet = self.RecordSet[MODEL_META_DATA_BUILD_OPTION]
+ UE = self.Module.UserExtensions
+ if UE == None:
+ UE = UserExtensionsClass()
+ for Record in RecordSet:
+ UE.BuildOptions.append(Record[0])
+ self.Module.UserExtensions = UE
+
+ ## GenIncludes
+ #
+ # Gen Includes of Inf
+ #
+ # @param ContainerFile: The Inf file full path
+ #
+ def GenIncludes(self, ContainerFile):
+ EdkLogger.debug(2, "Generate %s ..." % TAB_INCLUDES)
+ Includes = sdict()
+ # Get all Includes
+ RecordSet = self.RecordSet[MODEL_EFI_INCLUDE]
+ for Record in RecordSet:
+ Include = IncludeClass()
+ Include.FilePath = Record[0]
+ Include.SupArchList = Record[1]
+ if GenerateHelpText(Record[5], ''):
+ Include.HelpTextList.append(GenerateHelpText(Record[5], ''))
+ self.Module.Includes.append(Include)
+ #self.Module.FileList.extend(GetFiles(os.path.normpath(os.path.join(self.Identification.FileRelativePath, Include.FilePath)), ['CVS', '.svn']))
+
+ ## GenLibraryClasses
+ #
+ # Get LibraryClass of Inf
+ # <LibraryClassKeyWord>|<LibraryInstance>
+ #
+ # @param ContainerFile: The Inf file full path
+ #
+ def GenLibraryClasses(self, ContainerFile):
+ EdkLogger.debug(2, "Generate %s ..." % TAB_LIBRARY_CLASSES)
+ LibraryClasses = {}
+ # Get all LibraryClasses
+ RecordSet = self.RecordSet[MODEL_EFI_LIBRARY_CLASS]
+ for Record in RecordSet:
+ (LibClassName, LibClassIns, Pcd, SupModelList) = GetLibraryClassOfInf([Record[0], Record[4]], ContainerFile, self.WorkspaceDir, Record[2])
+ LibraryClass = CommonClass.LibraryClassClass()
+ LibraryClass.LibraryClass = LibClassName
+ LibraryClass.RecommendedInstance = LibClassIns
+ LibraryClass.FeatureFlag = Pcd
+ LibraryClass.SupArchList = Record[1]
+ LibraryClass.SupModuleList = Record[4]
+ if GenerateHelpText(Record[5], ''):
+ LibraryClass.HelpTextList.append(GenerateHelpText(Record[5], ''))
+ self.Module.LibraryClasses.append(LibraryClass)
+
+ ## GenPackages
+ #
+ # Gen Packages of Inf
+ #
+ # @param ContainerFile: The Inf file full path
+ #
+ def GenPackages(self, ContainerFile):
+ EdkLogger.debug(2, "Generate %s ..." % TAB_PACKAGES)
+ Packages = {}
+ # Get all Packages
+ RecordSet = self.RecordSet[MODEL_META_DATA_PACKAGE]
+ for Record in RecordSet:
+ (PackagePath, Pcd) = GetPackage(Record[0], ContainerFile, self.WorkspaceDir, Record[2])
+ Package = ModulePackageDependencyClass()
+ Package.FilePath = NormPath(PackagePath)
+ Package.SupArchList = Record[1]
+ Package.FeatureFlag = Pcd
+ if GenerateHelpText(Record[5], ''):
+ Package.HelpTextList.append(GenerateHelpText(Record[5], ''))
+ self.Module.PackageDependencies.append(Package)
+
+ def AddPcd(self, CName, TokenSpaceGuidCName, DefaultValue, ItemType, Arch, HelpTextList):
+ Pcd = PcdClass()
+ Pcd.CName = CName
+ Pcd.TokenSpaceGuidCName = TokenSpaceGuidCName
+ Pcd.DefaultValue = DefaultValue
+ Pcd.ItemType = ItemType
+ Pcd.SupArchList = Arch
+ if GenerateHelpText(HelpTextList, ''):
+ Pcd.HelpTextList.append(GenerateHelpText(HelpTextList, ''))
+ self.Module.PcdCodes.append(Pcd)
+
+ ## GenPcds
+ #
+ # Gen Pcds of Inf
+ # <TokenSpaceGuidCName>.<PcdCName>[|<Value>]
+ #
+ # @param ContainerFile: The Dec file full path
+ #
+ def GenPcds(self, ContainerFile):
+ EdkLogger.debug(2, "Generate %s ..." % TAB_PCDS)
+ Pcds = {}
+ PcdToken = {}
+
+ # Get all Pcds
+ RecordSet1 = self.RecordSet[MODEL_PCD_FIXED_AT_BUILD]
+ RecordSet2 = self.RecordSet[MODEL_PCD_PATCHABLE_IN_MODULE]
+ RecordSet3 = self.RecordSet[MODEL_PCD_FEATURE_FLAG]
+ RecordSet4 = self.RecordSet[MODEL_PCD_DYNAMIC_EX]
+ RecordSet5 = self.RecordSet[MODEL_PCD_DYNAMIC]
+
+ # Go through each arch
+ for Record in RecordSet1:
+ (TokenSpaceGuidCName, TokenName, Value, Type) = GetPcdOfInf(Record[0], TAB_PCDS_FIXED_AT_BUILD, ContainerFile, Record[2])
+ self.AddPcd(TokenName, TokenSpaceGuidCName, Value, Type, Record[1], Record[5])
+ for Record in RecordSet2:
+ (TokenSpaceGuidCName, TokenName, Value, Type) = GetPcdOfInf(Record[0], TAB_PCDS_PATCHABLE_IN_MODULE, ContainerFile, Record[2])
+ self.AddPcd(TokenName, TokenSpaceGuidCName, Value, Type, Record[1], Record[5])
+ for Record in RecordSet3:
+ (TokenSpaceGuidCName, TokenName, Value, Type) = GetPcdOfInf(Record[0], TAB_PCDS_FEATURE_FLAG, ContainerFile, Record[2])
+ self.AddPcd(TokenName, TokenSpaceGuidCName, Value, Type, Record[1], Record[5])
+ for Record in RecordSet4:
+ (TokenSpaceGuidCName, TokenName, Value, Type) = GetPcdOfInf(Record[0], TAB_PCDS_DYNAMIC_EX, ContainerFile, Record[2])
+ self.AddPcd(TokenName, TokenSpaceGuidCName, Value, Type, Record[1], Record[5])
+ for Record in RecordSet5:
+ (TokenSpaceGuidCName, TokenName, Value, Type) = GetPcdOfInf(Record[0], '', ContainerFile, Record[2])
+ self.AddPcd(TokenName, TokenSpaceGuidCName, Value, Type, Record[1], Record[5])
+
+ ## GenSources
+ #
+ # Gen Sources of Inf
+ # <Filename>[|<Family>[|<TagName>[|<ToolCode>[|<PcdFeatureFlag>]]]]
+ #
+ # @param ContainerFile: The Dec file full path
+ #
+ def GenSources(self, ContainerFile):
+ EdkLogger.debug(2, "Generate %s ..." % TAB_SOURCES)
+ Sources = {}
+
+ # Get all Sources
+ RecordSet = self.RecordSet[MODEL_EFI_SOURCE_FILE]
+ for Record in RecordSet:
+ (Filename, Family, TagName, ToolCode, Pcd) = GetSource(Record[0], ContainerFile, self.Identification.RelaPath, Record[2])
+ Source = ModuleSourceFileClass(Filename, TagName, ToolCode, Family, Pcd, Record[1])
+ if GenerateHelpText(Record[5], ''):
+ Source.HelpTextList.append(GenerateHelpText(Record[5], ''))
+ if MODEL_EFI_SOURCE_FILE in self.SectionHeaderCommentDict:
+ Source.HelpText = self.SectionHeaderCommentDict[MODEL_EFI_SOURCE_FILE]
+ self.Module.Sources.append(Source)
+ #self.Module.FileList.append(os.path.normpath(os.path.join(self.Identification.RelaPath, Filename)))
+
+ ## GenDepexes
+ #
+ # Gen Depex of Inf
+ #
+ # @param ContainerFile: The Inf file full path
+ #
+ def GenDepexes(self, ContainerFile):
+ EdkLogger.debug(2, "Generate %s ..." % TAB_DEPEX)
+ Depex = {}
+ # Get all Depexes
+ RecordSet = self.RecordSet[MODEL_EFI_DEPEX]
+ DepexString = ''
+ for Record in RecordSet:
+ DepexString = DepexString + Record[0] + '\n'
+ Dep = ModuleDepexClass()
+ if DepexString.endswith('\n'):
+ DepexString = DepexString[:len(DepexString) - len('\n')]
+ Dep.Depex = DepexString
+ if self.Module.ModuleHeader.ModuleType in ['DXE_SMM_DRIVER']:
+ self.Module.SmmDepex = Dep
+ elif self.Module.ModuleHeader.ModuleType in ['PEI_CORE', 'PEIM']:
+ self.Module.PeiDepex = Dep
+ else:
+ self.Module.DxeDepex = Dep
+# for Record in RecordSet:
+#
+# Dep = ModuleDepexClass()
+# Dep.Depex = Record[0]
+# Dep.SupArchList = Record[1]
+# if GenerateHelpText(Record[5], ''):
+# Dep.HelpTextList.append(GenerateHelpText(Record[5], ''))
+# DepexString = DepexString + Dep
+# List.append(Dep)
+# self.Module.Depex = List
+# if self.Module.ModuleHeader.ModuleType in ['DXE_SMM_DRIVER']:
+# self.Module.SmmDepex = List
+# elif self.Module.ModuleHeader.ModuleType in ['PEI_CORE', 'PEIM']:
+# self.Module.PeiDepex = List
+# else:
+# self.Module.DxeDepex = List
+
+ ## GenBinaries
+ #
+ # Gen Binary of Inf
+ # <FileType>|<Filename>|<Target>[|<TokenSpaceGuidCName>.<PcdCName>]
+ #
+ # @param ContainerFile: The Dec file full path
+ #
+ def GenBinaries(self, ContainerFile):
+ EdkLogger.debug(2, "Generate %s ..." % TAB_BINARIES)
+ Binaries = {}
+
+ # Get all Guids
+ RecordSet = self.RecordSet[MODEL_EFI_BINARY_FILE]
+ for Record in RecordSet:
+ (FileType, Filename, Target, Pcd) = GetBinary(Record[0], ContainerFile, self.Identification.RelaPath, Record[2])
+ Binary = ModuleBinaryFileClass(Filename, FileType, Target, Pcd, Record[1])
+ if GenerateHelpText(Record[5], ''):
+ Binary.HelpTextList.append(GenerateHelpText(Record[5], ''))
+ self.Module.Binaries.append(Binary)
+ #self.Module.FileList.append(os.path.normpath(os.path.join(self.Identification.RelaPath, Filename)))
+
+ ## GenGuids
+ #
+ # Gen Guids of Inf
+ # <CName>=<GuidValue>
+ #
+ # @param ContainerFile: The Inf file full path
+ #
+ def GenGuidProtocolPpis(self, Type, ContainerFile):
+ EdkLogger.debug(2, "Generate %s ..." % Type)
+ Lists = {}
+ # Get all Items
+ if Type == TAB_GUIDS:
+ ListMember = self.Module.Guids
+ elif Type == TAB_PROTOCOLS:
+ ListMember = self.Module.Protocols
+ elif Type == TAB_PPIS:
+ ListMember = self.Module.Ppis
+
+ RecordSet = self.RecordSet[Section[Type.upper()]]
+ for Record in RecordSet:
+ (Name, Value) = GetGuidsProtocolsPpisOfInf(Record[0], Type, ContainerFile, Record[2])
+ ListClass = GuidProtocolPpiCommonClass()
+ ListClass.CName = Name
+ ListClass.SupArchList = Record[1]
+ ListClass.FeatureFlag = Value
+ if GenerateHelpText(Record[5], ''):
+ ListClass.HelpTextList.append(GenerateHelpText(Record[5], ''))
+ ListMember.append(ListClass)
+
+##
+#
+# This acts like the main() function for the script, unless it is 'import'ed into another
+# script.
+#
+if __name__ == '__main__':
+ EdkLogger.Initialize()
+ EdkLogger.SetLevel(EdkLogger.QUIET)
+
+ W = os.getenv('WORKSPACE')
+ F = os.path.join(W, 'MdeModulePkg/Application/HelloWorld/HelloWorld.inf')
+
+ P = Inf(os.path.normpath(F), True, W, 'MdeModulePkg')
+ P.ShowModule()
+ print P.ModuleToInf(P.Module)
|